Merge branch '5.5' into CURA-10254-disable-interface-extruders

# Conflicts:
#	resources/definitions/fdmprinter.def.json

.github/ISSUE_TEMPLATE/SlicingCrash.yaml

@@ -0,0 +1,71 @@
+name: ❌ Slicing Failed
+description: When you see the message Slicing failed with an unexpected error
+labels: ["Type: Bug", "Status: Triage", "Slicing Error :collision:"]
+body:
+- type: markdown
+  attributes:
+    value: |
+       ### Project File
+       **⚠️ Before you continue, we need your project file to troubleshoot a slicing crash.**
+       It contains the printer and settings we need for troubleshooting. 
+       
+       ![Alt Text](https://user-images.githubusercontent.com/40423138/240616958-5a9751f2-bd34-4808-9752-6fde2e27516e.gif)
+       
+       To save a project file go to File -> Save project. 
+       Please make sure to .zip your project file. 
+       For big files, you may need to use [WeTransfer](https://wetransfer.com/) or similar file-sharing sites.
+       
+       🤔 Before you share, please think to yourself. Is this a model that can be shared?
+           Unfortunately we cannot help if this file is missing. 
+           Do you have the project file? Than let's continue ⬇️
+
+       ### Questions
+- type: input
+  attributes:
+    label: Cura Version
+    placeholder: 5.3.1
+  validations:
+    required: true
+- type: markdown
+  attributes:
+    value: |
+      We work hard on improving our slicing crashes. Our most recent release is 5.3.1.
+      If you are not on the latest version of Cura, [you can download it here](https://github.com/Ultimaker/Cura/releases/tag/5.3.1)
+- type: input
+  attributes:
+    label: Operating System
+    description: Information about the operating system the issue occurs on. Include at least the operating system and maybe GPU.
+    placeholder: Windows 11 / MacOS Catalina / MX Linux 
+  validations:
+    required: true
+- type: input
+  attributes:
+    label: Printer
+    description: Which printer was selected in Cura?
+  validations:
+    required: true
+- type: input
+  attributes:
+    label: Name abnormal settings
+    description: Are there any settings that you might have changed that caused the crash? Does your model slice when you select the default profiles?
+    placeholder:
+  validations:
+- type: input
+  attributes:
+    label: Describe model location
+    description: Does your model slice if you rotate the model 90 degrees or if you move it away from the center of the buildplate? 
+    placeholder:
+  validations:
+- type: input
+  attributes:
+    label: Describe your model
+    description: Have you sliced your model succesfully before? Is it watertight? Have you tried doing a quick [Mesh Fix with the Meshtools Plugin](https://marketplace.ultimaker.com/app/cura/plugins/fieldofview/MeshTools)? 
+  validations:
+    required: true
+- type: textarea
+  attributes:
+    label: Add your .zip here ⬇️ 
+    description: You can add the zip file and additional information that is relevant to the issue in the comments below.
+  validations:
+    required: true
+

.github/ISSUE_TEMPLATE/bugreport.yaml

@@ -1,40 +1,41 @@
-name: Bug Report
+name: 🪲 Bug Report
 description: Create a report to help us fix issues.
 labels: ["Type: Bug", "Status: Triage"]
 body:
 - type: markdown
   attributes:
     value: |
-      **Thank you for using Cura and wanting to report a bug.**
+      **Thank you for using Cura and wanting to report a bug. 🙏**
       
-      Before filing, please check if the issue already exists (either open or closed) by using the search bar on the issues page. If it does, comment there. Even if it's closed, we can reopen it based on your comment. 
+      Before filing, [please check if the issue already exists](https://github.com/Ultimaker/Cura/issues?q=is%3Aissue) by using the search bar on the issues page. 
+      If it does, comment there. Even if it's closed, we can reopen it based on your comment. 
       
-      Also, please note the application version in the title of the issue "For example (3.2.1) Cannot connect to 3rd-party printer". Please do not write things like **Request** or **BUG** in the title, this is what labels are for.
+      Please include the cura version in the title of the issue. For example, *"[5.4.0] Support Brim is missing in this model"*. 
 - type: input
   attributes:
-    label: Application Version
+    label: Cura Version
     description: The version of Cura this issue occurs with.
-    placeholder: 5.0.0
+    placeholder: 5.4.0
   validations:
     required: true
 - type: input
   attributes:
-    label: Platform
+    label: Operating System
     description: Information about the operating system the issue occurs on. Include at least the operating system and maybe GPU.
-    placeholder: Windows 10
+    placeholder:  Windows 11 / MacOS Catalina / MX Linux 
   validations:
     required: true
 - type: input
   attributes:
     label: Printer
-    description: Which printer was selected in Cura?
-    placeholder: Ultimaker S5    
+    description: Which printer was selected in Cura? It also helps to mention if you made any firmware modifications to your printer. 
+    placeholder: Ultimaker S7 / Creality CR-10 with Klipper     
   validations:
     required: true
 - type: textarea
   attributes:
     label: Reproduction steps
-    description: Tell us what you did!
+    description: Share what you did, so we can reproduce it
     placeholder: |
       1. Something you did
       2. Something you did next
@@ -43,40 +44,39 @@ body:
 - type: textarea
   attributes:
     label: Actual results
-    description: What happens after the above steps have been followed.
+    description: What happens after the above steps have been followed?
   validations:
     required: true
 - type: textarea
   attributes:
     label: Expected results
-    description: What should happen after the above steps have been followed.
+    description: What should happen after the above steps have been followed?
   validations:
     required: true
 - type: markdown
   attributes:
     value: |
-      Please be sure to add the following files:
-        * For slicing issues, upload a **project file** that clearly shows the bug. 
-          To save a project file go to `File -> Save project`. Please make sure to .zip your project file. For big files you may need to use WeTransfer or similar file sharing sites. 
-          G-code files are not project files!
-        * **Screenshots** of showing the problem, perhaps before/after images.
-        * A **log file** for crashes and similar issues.
-          You can find your log file here:
-          Windows: `%APPDATA%\cura\<Cura version>\cura.log` or usually `C:\Users\\<your username>\AppData\Roaming\cura\<Cura version>\cura.log`
-          MacOS: `$USER/Library/Application Support/cura/<Cura version>/cura.log`
-          Ubuntu/Linux: `$USER/.local/share/cura/<Cura version>/cura.log` 
-          
-          If the Cura user interface still starts, you can also reach this directory from the application menu in Help -> Show settings folder 
-- type: checkboxes
-  attributes:
-    label: Checklist of files to include
-    options:
-      - label: Log file
-      - label: Project file
+      ### Please add the following files when they are related to...
+        * 🔵 **The quality of your print**   
+          Please add **a Project File**. It contains the printer and settings we need for troubleshooting.    
+          To save a project file go to File -> Save project. 
+          Please make sure to .zip your project file. For big files, you may need to use [WeTransfer](https://wetransfer.com/) or similar file-sharing sites. 
+          G-code files are not project files! Before you share, please think to yourself. Is this a model that can be shared?
+          ![Alt Text](https://user-images.githubusercontent.com/40423138/240616958-5a9751f2-bd34-4808-9752-6fde2e27516e.gif)
+       * 🔵 **Using and interacting with Cura** 
+           Please add **screenshots** showing the issue. 
+           Before and after, and arrows can help here. 
+       * 🔵 **Unexpected crashes and behavior**
+           Please add **a log file** with information on what your Cura is doing.  
+           You can find your log file here:
+           Windows: `%APPDATA%\cura\<Cura version>\cura.log`
+           MacOS: `$USER/Library/Application Support/cura/<Cura version>/cura.log`
+           Ubuntu/Linux: `$USER/.local/share/cura/<Cura version>/cura.log` 
+           If the Cura user interface still starts, you can also reach this directory from the application menu in Help -> Show settings folder 
+
 - type: textarea
   attributes:
-    label: Additional information & file uploads  
-    description: You can add these files and additional information that is relevant to the issue in the comments below.
+    label: Add your .zip and screenshots here ⬇️ 
+    description: You can add the zip file and additional information that is relevant to the issue in the comments below.
   validations:
     required: true
-

.github/ISSUE_TEMPLATE/featurerequest.yaml

@@ -1,4 +1,4 @@
-name: Feature Request
+name: 💡 Feature Request
 description: Suggest an idea for this project.
 labels: ["Type: New Feature", "Status: Triage"]
 body:

.github/PULL_REQUEST_TEMPLATE.md

@@ -28,6 +28,6 @@ This fixes... OR This improves... -->
 <!-- Check if relevant -->
 
 - [ ] My code follows the style guidelines of this project as described in [UltiMaker Meta](https://github.com/Ultimaker/Meta) and [Cura QML best practices](https://github.com/Ultimaker/Cura/wiki/QML-Best-Practices)
-- [ ] I have read the [Contribution guide](https://github.com/Ultimaker/Cura/blob/main/contributing.md) 
+- [ ] I have read the [Contribution guide](https://github.com/Ultimaker/Cura/blob/main/CONTRIBUTING.md) 
 - [ ] I have commented my code, particularly in hard-to-understand areas
-- [ ] I have uploaded any files required to test this change
+- [ ] I have uploaded any files required to test this change

.github/workflows/conan-package-create.yml

@@ -1,188 +1,153 @@
 name: Create and Upload Conan package
 
 on:
-    workflow_call:
-        inputs:
-            project_name:
-                required: true
-                type: string
+  workflow_call:
+    inputs:
+      project_name:
+        required: true
+        type: string
 
-            recipe_id_full:
-                required: true
-                type: string
+      recipe_id_full:
+        required: true
+        type: string
 
-            build_id:
-                required: true
-                type: number
+      build_id:
+        required: true
+        type: number
 
-            build_info:
-                required: false
-                default: true
-                type: boolean
+      build_info:
+        required: false
+        default: true
+        type: boolean
 
-            recipe_id_latest:
-                required: false
-                type: string
+      recipe_id_latest:
+        required: false
+        type: string
 
-            runs_on:
-                required: true
-                type: string
+      runs_on:
+        required: true
+        type: string
 
-            python_version:
-                required: true
-                type: string
+      python_version:
+        required: true
+        type: string
 
-            conan_config_branch:
-                required: false
-                type: string
+      conan_config_branch:
+        required: false
+        type: string
 
-            conan_logging_level:
-                required: false
-                type: string
+      conan_logging_level:
+        required: false
+        type: string
 
-            conan_clean_local_cache:
-                required: false
-                type: boolean
-                default: false
+      conan_clean_local_cache:
+        required: false
+        type: boolean
+        default: false
 
-            conan_upload_community:
-                required: false
-                default: true
-                type: boolean
+      conan_upload_community:
+        required: false
+        default: true
+        type: boolean
 
 env:
-    CONAN_LOGIN_USERNAME_CURA: ${{ secrets.CONAN_USER }}
-    CONAN_PASSWORD_CURA: ${{ secrets.CONAN_PASS }}
-    CONAN_LOGIN_USERNAME_CURA_CE: ${{ secrets.CONAN_USER }}
-    CONAN_PASSWORD_CURA_CE: ${{ secrets.CONAN_PASS }}
-    CONAN_LOG_RUN_TO_OUTPUT: 1
-    CONAN_LOGGING_LEVEL: ${{ inputs.conan_logging_level }}
-    CONAN_NON_INTERACTIVE: 1
+  CONAN_LOGIN_USERNAME: ${{ secrets.CONAN_USER }}
+  CONAN_PASSWORD: ${{ secrets.CONAN_PASS }}
+  CONAN_LOG_RUN_TO_OUTPUT: 1
+  CONAN_LOGGING_LEVEL: ${{ inputs.conan_logging_level }}
+  CONAN_NON_INTERACTIVE: 1
 
 jobs:
-    conan-package-create:
-        runs-on: ${{ inputs.runs_on }}
+  conan-package-create:
+    runs-on: ${{ inputs.runs_on }}
 
-        steps:
-            -   name: Checkout
-                uses: actions/checkout@v3
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
 
-            -   name: Setup Python and pip
-                uses: actions/setup-python@v4
-                with:
-                    python-version: ${{ inputs.python_version }}
-                    cache: 'pip'
-                    cache-dependency-path: .github/workflows/requirements-conan-package.txt
+      - name: Setup Python and pip
+        uses: actions/setup-python@v4
+        with:
+          python-version: ${{ inputs.python_version }}
+          cache: 'pip'
+          cache-dependency-path: .github/workflows/requirements-conan-package.txt
 
-            -   name: Install Python requirements for runner
-                run: pip install -r https://raw.githubusercontent.com/Ultimaker/Cura/main/.github/workflows/requirements-conan-package.txt
-                #  Note the runner requirements are always installed from the main branch in the Ultimaker/Cura repo
+      - name: Install Python requirements for runner
+        run: pip install -r https://raw.githubusercontent.com/Ultimaker/Cura/main/.github/workflows/requirements-conan-package.txt
+        #  Note the runner requirements are always installed from the main branch in the Ultimaker/Cura repo
 
-            -   name: Use Conan download cache (Bash)
-                if: ${{ runner.os != 'Windows' }}
-                run: conan config set storage.download_cache="$HOME/.conan/conan_download_cache"
+      - name: Use Conan download cache (Bash)
+        if: ${{ runner.os != 'Windows' }}
+        run: conan config set storage.download_cache="$HOME/.conan/conan_download_cache"
 
-            -   name: Use Conan download cache (Powershell)
-                if: ${{ runner.os == 'Windows' }}
-                run: conan config set storage.download_cache="C:\Users\runneradmin\.conan\conan_download_cache"
+      - name: Use Conan download cache (Powershell)
+        if: ${{ runner.os == 'Windows' }}
+        run: conan config set storage.download_cache="C:\Users\runneradmin\.conan\conan_download_cache"
 
-            -   name: Cache Conan local repository packages (Bash)
-                uses: actions/cache@v3
-                if: ${{ runner.os != 'Windows' }}
-                with:
-                    path: |
-                        $HOME/.conan/data
-                        $HOME/.conan/conan_download_cache
-                    key: conan-${{ inputs.runs_on }}-${{ runner.arch }}-create-cache
+      - name: Cache Conan local repository packages (Bash)
+        uses: actions/cache@v3
+        if: ${{ runner.os != 'Windows' }}
+        with:
+          path: |
+            $HOME/.conan/data
+            $HOME/.conan/conan_download_cache
+          key: conan-${{ inputs.runs_on }}-${{ runner.arch }}-create-cache
 
-            -   name: Cache Conan local repository packages (Powershell)
-                uses: actions/cache@v3
-                if: ${{ runner.os == 'Windows' }}
-                with:
-                    path: |
-                        C:\Users\runneradmin\.conan\data
-                        C:\.conan
-                        C:\Users\runneradmin\.conan\conan_download_cache
-                    key: conan-${{ inputs.runs_on }}-${{ runner.arch }}-create-cache
+      - name: Cache Conan local repository packages (Powershell)
+        uses: actions/cache@v3
+        if: ${{ runner.os == 'Windows' }}
+        with:
+          path: |
+            C:\Users\runneradmin\.conan\data
+            C:\.conan
+            C:\Users\runneradmin\.conan\conan_download_cache
+          key: conan-${{ inputs.runs_on }}-${{ runner.arch }}-create-cache
 
-            -   name: Install MacOS system requirements
-                if:  ${{ runner.os == 'Macos' }}
-                run: brew install autoconf automake ninja
+      - name: Install MacOS system requirements
+        if: ${{ runner.os == 'Macos' }}
+        run: brew install autoconf automake ninja
 
-            -   name: Install Linux system requirements
-                if: ${{ runner.os == 'Linux' }}
-                run: |
-                    sudo add-apt-repository ppa:ubuntu-toolchain-r/test -y
-                    sudo apt update
-                    sudo apt upgrade
-                    sudo apt install build-essential checkinstall libegl-dev zlib1g-dev libssl-dev ninja-build autoconf libx11-dev libx11-xcb-dev libfontenc-dev libice-dev libsm-dev libxau-dev libxaw7-dev libxcomposite-dev libxcursor-dev libxdamage-dev libxdmcp-dev libxext-dev libxfixes-dev libxi-dev libxinerama-dev libxkbfile-dev libxmu-dev libxmuu-dev libxpm-dev libxrandr-dev libxrender-dev libxres-dev libxss-dev libxt-dev libxtst-dev libxv-dev libxvmc-dev libxxf86vm-dev xtrans-dev libxcb-render0-dev libxcb-render-util0-dev libxcb-xkb-dev libxcb-icccm4-dev libxcb-image0-dev libxcb-keysyms1-dev libxcb-randr0-dev libxcb-shape0-dev libxcb-sync-dev libxcb-xfixes0-dev libxcb-xinerama0-dev xkb-data libxcb-dri3-dev uuid-dev libxcb-util-dev libxkbcommon-x11-dev pkg-config flex bison -y
+      # NOTE: Due to what are probably github issues, we have to remove the cache and reconfigure before the rest.
+      #       This is maybe because grub caches the disk it uses last time, which is recreated each time.
+      - name: Install Linux system requirements
+        if: ${{ runner.os == 'Linux' }}
+        run: |
+          sudo rm /var/cache/debconf/config.dat
+          sudo dpkg --configure -a
+          sudo add-apt-repository ppa:ubuntu-toolchain-r/test -y
+          sudo apt update
+          sudo apt upgrade
+          sudo apt install build-essential checkinstall libegl-dev zlib1g-dev libssl-dev ninja-build autoconf libx11-dev libx11-xcb-dev libfontenc-dev libice-dev libsm-dev libxau-dev libxaw7-dev libxcomposite-dev libxcursor-dev libxdamage-dev libxdmcp-dev libxext-dev libxfixes-dev libxi-dev libxinerama-dev libxkbfile-dev libxmu-dev libxmuu-dev libxpm-dev libxrandr-dev libxrender-dev libxres-dev libxss-dev libxt-dev libxtst-dev libxv-dev libxvmc-dev libxxf86vm-dev xtrans-dev libxcb-render0-dev libxcb-render-util0-dev libxcb-xkb-dev libxcb-icccm4-dev libxcb-image0-dev libxcb-keysyms1-dev libxcb-randr0-dev libxcb-shape0-dev libxcb-sync-dev libxcb-xfixes0-dev libxcb-xinerama0-dev xkb-data libxcb-dri3-dev uuid-dev libxcb-util-dev libxkbcommon-x11-dev pkg-config flex bison -y
 
-            -   name: Install GCC-12 on ubuntu-22.04
-                if: ${{ startsWith(inputs.runs_on, 'ubuntu-22.04') }}
-                run: |
-                    sudo apt install g++-12 gcc-12 -y
-                    sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-12 12
-                    sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-12 12
+      - name: Install GCC-13 on ubuntu
+        if: ${{ startsWith(inputs.runs_on, 'ubuntu') }}
+        run: |
+          sudo apt install g++-13 gcc-13 -y
+          sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-13 13
+          sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-13 13
 
-            -   name: Use GCC-10 on ubuntu-20.04
-                if: ${{ startsWith(inputs.runs_on, 'ubuntu-20.04') }}
-                run: |
-                    sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-10 10
-                    sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-10 10
+      - name: Create the default Conan profile
+        run: conan profile new default --detect
 
-            -   name: Create the default Conan profile
-                run:  conan profile new default --detect
+      - name: Get Conan configuration from branch
+        if: ${{ inputs.conan_config_branch != '' }}
+        run: conan config install https://github.com/Ultimaker/conan-config.git -a "-b ${{ inputs.conan_config_branch }}"
 
-            -   name: Get Conan configuration from branch
-                if: ${{ inputs.conan_config_branch != '' }}
-                run: conan config install https://github.com/Ultimaker/conan-config.git -a "-b ${{ inputs.conan_config_branch }}"
+      - name: Get Conan configuration
+        run: |
+          conan config install https://github.com/Ultimaker/conan-config.git
+          conan config install https://github.com/Ultimaker/conan-config.git -a "-b runner/${{ runner.os }}/${{ runner.arch }}"
 
-            -   name: Get Conan configuration
-                if: ${{ inputs.conan_config_branch == '' }}
-                run: conan config install https://github.com/Ultimaker/conan-config.git
+      - name: Add Cura private Artifactory remote
+        run: conan remote add cura-private https://ultimaker.jfrog.io/artifactory/api/conan/cura-private True
 
-            -   name: Create the lock file
-                if: ${{ inputs.build_info }}
-                run: |
-                    conan_build_info --v2 start ${{ inputs.project_name }} ${{ github.run_number }}000${{ inputs.build_id }}
-                    conan lock create --reference ${{ inputs.recipe_id_full }} --lockfile-out=conan.lock                    
+      - name: Create the Packages
+        run: conan install ${{ inputs.recipe_id_full }} --build=missing --update -c tools.build:skip_test=True
 
-            -   name: Create the Packages using lockfile
-                if: ${{ inputs.build_info }}
-                run: conan install ${{ inputs.recipe_id_full }} --build=missing --update --lockfile=conan.lock --lockfile-out=conan.lock
+      - name: Upload the Package(s)
+        if: ${{ always() && inputs.conan_upload_community }}
+        run: conan upload ${{ inputs.recipe_id_full }} -r cura --all -c
 
-            -   name: Create the Packages
-                if: ${{ ! inputs.build_info }}
-                run: conan install ${{ inputs.recipe_id_full }} --build=missing --update
-
-            -   name: Create the build info
-                if: ${{ inputs.build_info }}
-                run: conan_build_info --v2 create buildinfo.json --lockfile conan.lock --user ${{ secrets.CONAN_USER }} --password ${{ secrets.CONAN_PASS }}
-
-            -   name: Upload the Package(s)
-                if: always()
-                run: conan upload "*" -r cura --all -c
-
-            -   name: Upload the build info
-                if: ${{ inputs.build_info }}
-                run: |
-                    conan_build_info --v2 publish buildinfo.json --url https://ultimaker.jfrog.io/artifactory --user ${{ secrets.CONAN_USER }} --password ${{ secrets.CONAN_PASS }}
-                    conan_build_info --v2 stop
-
-            -   name: Upload the Package(s) community
-                if: ${{ always() && inputs.conan_upload_community == true }}
-                run: conan upload "*" -r cura-ce -c
-
-            -   name: Upload the log and build artifacts
-                if: always()
-                uses: actions/upload-artifact@v3
-                with:
-                    name: log-${{ inputs.runs_on }}-${{ runner.arch }}
-                    path: |
-                        buildinfo.json
-                        conan.lock
-                        conanbuildinfo.txt
-                        conaninfo.txt
-                        graph_info.json
-                        build/**
-                    retention-days: 1
+      - name: Upload the Package(s) to the private Artifactory
+        if: ${{ always() && ! inputs.conan_upload_community }}
+        run: conan upload ${{ inputs.recipe_id_full }} -r cura-private --all -c

.github/workflows/conan-package.yml

@@ -7,110 +7,139 @@ name: conan-package
 # It should run on pushes against main or CURA-* branches, but it will only create the binaries for main and release branches
 
 on:
-    workflow_dispatch:
-        inputs:
-            create_binaries_windows:
-                required: true
-                default: false
-                description: 'create binaries Windows'
-            create_binaries_linux:
-                required: true
-                default: false
-                description: 'create binaries Linux'
-            create_binaries_macos:
-                required: true
-                default: false
-                description: 'create binaries Macos'
+  workflow_dispatch:
+    inputs:
+      create_binaries_windows:
+        required: true
+        default: false
+        description: 'create binaries Windows'
+      create_binaries_linux:
+        required: true
+        default: false
+        description: 'create binaries Linux'
+      create_binaries_macos:
+        required: true
+        default: false
+        description: 'create binaries Macos'
 
-    push:
-        paths:
-            - 'plugins/**'
-            - 'resources/**'
-            - 'cura/**'
-            - 'icons/**'
-            - 'tests/**'
-            - 'packaging/**'
-            - '.github/workflows/conan-*.yml'
-            - '.github/workflows/notify.yml'
-            - '.github/workflows/requirements-conan-package.txt'
-            - 'requirements*.txt'
-            - 'conanfile.py'
-            - 'conandata.yml'
-            - 'GitVersion.yml'
-            - '*.jinja'
-        branches:
-            - main
-            - 'CURA-*'
-            - '[1-9].[0-9]'
-            - '[1-9].[0-9][0-9]'
-        tags:
-            - '[1-9].[0-9].[0-9]*'
-            - '[1-9].[0-9].[0-9]'
-            - '[1-9].[0-9][0-9].[0-9]*'
+  push:
+    paths:
+      - 'plugins/**'
+      - 'resources/**'
+      - 'cura/**'
+      - 'icons/**'
+      - 'tests/**'
+      - 'packaging/**'
+      - '.github/workflows/conan-*.yml'
+      - '.github/workflows/notify.yml'
+      - '.github/workflows/requirements-conan-package.txt'
+      - 'requirements*.txt'
+      - 'conanfile.py'
+      - 'conandata.yml'
+      - 'GitVersion.yml'
+      - '*.jinja'
+    branches:
+      - main
+      - 'CURA-*'
+      - '[1-9].[0-9]'
+      - '[1-9].[0-9][0-9]'
+    tags:
+      - '[1-9].[0-9].[0-9]*'
+      - '[1-9].[0-9].[0-9]'
+      - '[1-9].[0-9][0-9].[0-9]*'
 
-permissions: {}
+env:
+  CONAN_LOGIN_USERNAME_CURA: ${{ secrets.CONAN_USER }}
+  CONAN_PASSWORD_CURA: ${{ secrets.CONAN_PASS }}
+  CONAN_LOGIN_USERNAME_CURA_CE: ${{ secrets.CONAN_USER }}
+  CONAN_PASSWORD_CURA_CE: ${{ secrets.CONAN_PASS }}
+  CONAN_LOG_RUN_TO_OUTPUT: 1
+  CONAN_LOGGING_LEVEL: ${{ inputs.conan_logging_level }}
+  CONAN_NON_INTERACTIVE: 1
+
+permissions: { }
 jobs:
-    conan-recipe-version:
-        permissions:
-          contents: read
+  conan-recipe-version:
+    permissions:
+      contents: read
 
-        uses: ultimaker/cura/.github/workflows/conan-recipe-version.yml@main
+    uses: ultimaker/cura/.github/workflows/conan-recipe-version.yml@main
+    with:
+      project_name: cura
+
+  conan-package-create-linux:
+    needs: [ conan-recipe-version ]
+    runs-on: 'ubuntu-latest'
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+
+      - name: Cache Conan data
+        id: cache-conan
+        uses: actions/cache@v3
         with:
-            project_name: cura
+          path: ~/.conan
+          key: ${{ runner.os }}-conan
 
-    conan-package-export:
-        permissions:
-          contents: read
-
-        needs: [ conan-recipe-version ]
-        uses: ultimaker/cura/.github/workflows/conan-recipe-export.yml@main
+      - name: Setup Python and pip
+        uses: actions/setup-python@v4
         with:
-            recipe_id_full: ${{ needs.conan-recipe-version.outputs.recipe_id_full }}
-            recipe_id_latest: ${{ needs.conan-recipe-version.outputs.recipe_id_latest }}
-            runs_on: 'ubuntu-20.04'
-            python_version: '3.10.x'
-            conan_logging_level: 'info'
-        secrets: inherit
+          python-version: '3.11.x'
+          cache: 'pip'
+          cache-dependency-path: .github/workflows/requirements-conan-package.txt
 
-    conan-package-create-linux:
-        permissions:
-          contents: read
+      - name: Install Python requirements for runner
+        run: pip install -r .github/workflows/requirements-conan-package.txt
 
-        if: ${{ (github.event_name == 'push' && (github.ref_name == 'main' || github.ref_name == 'master' || needs.conan-recipe-version.outputs.is_release_branch == 'true')) || (github.event_name == 'workflow_dispatch' && inputs.create_binaries_linux) }}
-        needs: [ conan-recipe-version, conan-package-export ]
+      # NOTE: Due to what are probably github issues, we have to remove the cache and reconfigure before the rest.
+      #       This is maybe because grub caches the disk it uses last time, which is recreated each time.
+      - name: Install Linux system requirements
+        if: ${{ runner.os == 'Linux' }}
+        run: |
+          sudo rm /var/cache/debconf/config.dat
+          sudo dpkg --configure -a
+          sudo add-apt-repository ppa:ubuntu-toolchain-r/test -y
+          sudo apt update
+          sudo apt upgrade
+          sudo apt install efibootmgr build-essential checkinstall libegl-dev zlib1g-dev libssl-dev ninja-build autoconf libx11-dev libx11-xcb-dev libfontenc-dev libice-dev libsm-dev libxau-dev libxaw7-dev libxcomposite-dev libxcursor-dev libxdamage-dev libxdmcp-dev libxext-dev libxfixes-dev libxi-dev libxinerama-dev libxkbfile-dev libxmu-dev libxmuu-dev libxpm-dev libxrandr-dev libxrender-dev libxres-dev libxss-dev libxt-dev libxtst-dev libxv-dev libxvmc-dev libxxf86vm-dev xtrans-dev libxcb-render0-dev libxcb-render-util0-dev libxcb-xkb-dev libxcb-icccm4-dev libxcb-image0-dev libxcb-keysyms1-dev libxcb-randr0-dev libxcb-shape0-dev libxcb-sync-dev libxcb-xfixes0-dev libxcb-xinerama0-dev xkb-data libxcb-dri3-dev uuid-dev libxcb-util-dev libxkbcommon-x11-dev pkg-config flex bison g++-12 gcc-12 -y
 
-        uses: ultimaker/cura/.github/workflows/conan-package-create.yml@main
-        with:
-            project_name: ${{ needs.conan-recipe-version.outputs.project_name }}
-            recipe_id_full: ${{ needs.conan-recipe-version.outputs.recipe_id_full }}
-            build_id: 1
-            runs_on: 'ubuntu-20.04'
-            python_version: '3.10.x'
-            conan_logging_level: 'info'
-        secrets: inherit
+      - name: Install GCC-13
+        run: |
+          sudo apt install g++-13 gcc-13 -y
+          sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-13 13
+          sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-13 13
 
-    notify-export:
-        if: ${{ always() }}
-        needs: [ conan-recipe-version, conan-package-export ]
+      - name: Create the default Conan profile
+        run: conan profile new default --detect --force
 
-        uses: ultimaker/cura/.github/workflows/notify.yml@main
-        with:
-            success: ${{ contains(join(needs.*.result, ','), 'success') }}
-            success_title: "New Conan recipe exported in ${{ github.repository }}"
-            success_body: "Exported ${{ needs.conan-recipe-version.outputs.recipe_id_full }}"
-            failure_title: "Failed to export Conan Export in ${{ github.repository }}"
-            failure_body: "Failed to exported ${{ needs.conan-recipe-version.outputs.recipe_id_full }}"
-        secrets: inherit
+      - name: Get Conan configuration
+        run: |
+          conan config install https://github.com/Ultimaker/conan-config.git
+          conan config install https://github.com/Ultimaker/conan-config.git -a "-b runner/${{ runner.os }}/${{ runner.arch }}"
 
-    notify-create:
-        if: ${{ always() && ((github.event_name == 'push' && (github.ref_name == 'main' || github.ref_name == 'master' || needs.conan-recipe-version.outputs.is_release_branch == 'true')) || (github.event_name == 'workflow_dispatch' && inputs.create_binaries_linux)) }}
-        needs: [ conan-recipe-version, conan-package-create-linux ]
+      - name: Create the Packages
+        run: conan create . ${{ needs.conan-recipe-version.outputs.recipe_id_full }} --build=missing --update -o ${{ needs.conan-recipe-version.outputs.project_name }}:devtools=True -c tools.build:skip_test=True
 
-        uses: ultimaker/cura/.github/workflows/notify.yml@main
-        with:
-            success: ${{ contains(join(needs.*.result, ','), 'success') }}
-            success_title: "New binaries created in ${{ github.repository }}"
-            success_body: "Created binaries for ${{ needs.conan-recipe-version.outputs.recipe_id_full }}"
-            failure_title: "Failed to create binaries in ${{ github.repository }}"
-            failure_body: "Failed to created binaries for ${{ needs.conan-recipe-version.outputs.recipe_id_full }}"
-        secrets: inherit
+      - name: Create the latest alias
+        if: always()
+        run: conan alias ${{ needs.conan-recipe-version.outputs.recipe_id_latest }} ${{ needs.conan-recipe-version.outputs.recipe_id_full }}
+
+      - name: Upload the Package(s)
+        if: always()
+        run: |
+          conan upload ${{ needs.conan-recipe-version.outputs.recipe_id_full }} -r cura --all -c
+          conan upload ${{ needs.conan-recipe-version.outputs.recipe_id_latest }} -r cura -c
+
+  notify-create:
+    if: ${{ always() && (github.event_name == 'push' && (github.ref_name == 'main' || github.ref_name == 'master' || needs.conan-recipe-version.outputs.is_release_branch == 'true')) }}
+    needs: [ conan-recipe-version, conan-package-create-linux ]
+
+    uses: ultimaker/cura/.github/workflows/notify.yml@main
+    with:
+      success: ${{ contains(join(needs.*.result, ','), 'success') }}
+      success_title: "New binaries created in ${{ github.repository }}"
+      success_body: "Created binaries for ${{ needs.conan-recipe-version.outputs.recipe_id_full }}"
+      failure_title: "Failed to create binaries in ${{ github.repository }}"
+      failure_body: "Failed to created binaries for ${{ needs.conan-recipe-version.outputs.recipe_id_full }}"
+    secrets: inherit

.github/workflows/conan-recipe-export.yml

@@ -1,107 +1,107 @@
 name: Export Conan Recipe to server
 
 on:
-    workflow_call:
-        inputs:
-            recipe_id_full:
-                required: true
-                type: string
+  workflow_call:
+    inputs:
+      recipe_id_full:
+        required: true
+        type: string
 
-            recipe_id_latest:
-                required: false
-                type: string
+      recipe_id_latest:
+        required: false
+        type: string
 
-            runs_on:
-                required: true
-                type: string
+      runs_on:
+        required: true
+        type: string
 
-            python_version:
-                required: true
-                type: string
+      python_version:
+        required: true
+        type: string
 
-            conan_config_branch:
-                required: false
-                type: string
+      conan_config_branch:
+        required: false
+        type: string
 
-            conan_logging_level:
-                required: false
-                type: string
+      conan_logging_level:
+        required: false
+        type: string
 
-            conan_export_binaries:
-                required: false
-                type: boolean
+      conan_export_binaries:
+        required: false
+        type: boolean
 
-            conan_upload_community:
-                required: false
-                default: true
-                type: boolean
+      conan_upload_community:
+        required: false
+        default: true
+        type: boolean
 
 env:
-    CONAN_LOGIN_USERNAME_CURA: ${{ secrets.CONAN_USER }}
-    CONAN_PASSWORD_CURA: ${{ secrets.CONAN_PASS }}
-    CONAN_LOGIN_USERNAME_CURA_CE: ${{ secrets.CONAN_USER }}
-    CONAN_PASSWORD_CURA_CE: ${{ secrets.CONAN_PASS }}
-    CONAN_LOG_RUN_TO_OUTPUT: 1
-    CONAN_LOGGING_LEVEL: ${{ inputs.conan_logging_level }}
-    CONAN_NON_INTERACTIVE: 1
+  CONAN_LOGIN_USERNAME: ${{ secrets.CONAN_USER }}
+  CONAN_PASSWORD: ${{ secrets.CONAN_PASS }}
+  CONAN_LOG_RUN_TO_OUTPUT: 1
+  CONAN_LOGGING_LEVEL: ${{ inputs.conan_logging_level }}
+  CONAN_NON_INTERACTIVE: 1
 
 jobs:
-    package-export:
-        runs-on: ${{ inputs.runs_on }}
+  package-export:
+    runs-on: ${{ inputs.runs_on }}
 
-        steps:
-            -   name: Checkout project
-                uses: actions/checkout@v3
+    steps:
+      - name: Checkout project
+        uses: actions/checkout@v3
 
-            -   name: Setup Python and pip
-                uses: actions/setup-python@v4
-                with:
-                    python-version: ${{ inputs.python_version }}
-                    cache: 'pip'
-                    cache-dependency-path: .github/workflows/requirements-conan-package.txt
+      - name: Setup Python and pip
+        uses: actions/setup-python@v4
+        with:
+          python-version: ${{ inputs.python_version }}
+          cache: 'pip'
+          cache-dependency-path: .github/workflows/requirements-conan-package.txt
 
-            -   name: Install Python requirements and Create default Conan profile
-                run: |
-                    pip install -r https://raw.githubusercontent.com/Ultimaker/Cura/main/.github/workflows/requirements-conan-package.txt
-                    conan profile new default --detect
-                #  Note the runner requirements are always installed from the main branch in the Ultimaker/Cura repo
+      - name: Install Python requirements and Create default Conan profile
+        run: |
+          pip install -r https://raw.githubusercontent.com/Ultimaker/Cura/main/.github/workflows/requirements-conan-package.txt
+          conan profile new default --detect
+        #  Note the runner requirements are always installed from the main branch in the Ultimaker/Cura repo
 
-            -   name: Cache Conan local repository packages
-                uses: actions/cache@v3
-                with:
-                    path: $HOME/.conan/data
-                    key: ${{ runner.os }}-conan-export-cache
+      - name: Cache Conan local repository packages
+        uses: actions/cache@v3
+        with:
+          path: $HOME/.conan/data
+          key: ${{ runner.os }}-conan-export-cache
 
-            -   name: Get Conan configuration from branch
-                if: ${{ inputs.conan_config_branch != '' }}
-                run: conan config install https://github.com/Ultimaker/conan-config.git -a "-b ${{ inputs.conan_config_branch }}"
+      - name: Get Conan configuration from branch
+        if: ${{ inputs.conan_config_branch != '' }}
+        run: conan config install https://github.com/Ultimaker/conan-config.git -a "-b ${{ inputs.conan_config_branch }}"
 
-            -   name: Get Conan configuration
-                if: ${{ inputs.conan_config_branch == '' }}
-                run: conan config install https://github.com/Ultimaker/conan-config.git
+      - name: Get Conan configuration
+        run: |
+          conan config install https://github.com/Ultimaker/conan-config.git
+          conan config install https://github.com/Ultimaker/conan-config.git -a "-b runner/${{ runner.os }}/${{ runner.arch }}"
 
-            -   name: Export the Package (binaries)
-                if: ${{ inputs.conan_export_binaries }}
-                run: conan create . ${{ inputs.recipe_id_full }} --build=missing --update
+      - name: Add Cura private Artifactory remote
+        run: conan remote add cura-private https://ultimaker.jfrog.io/artifactory/api/conan/cura-private True
 
-            -   name: Export the Package
-                if: ${{ !inputs.conan_export_binaries }}
-                run: conan export . ${{ inputs.recipe_id_full }}
+      - name: Export the Package (binaries)
+        if: ${{ inputs.conan_export_binaries }}
+        run: conan create . ${{ inputs.recipe_id_full }} --build=missing --update -c tools.build:skip_test=True
 
-            -   name: Remove the latest alias
-                if: ${{ inputs.recipe_id_latest != '' && runner.os == 'Linux' }}
-                run: |
-                    conan remove ${{ inputs.recipe_id_latest }} -r cura -f || true
-                    conan remove ${{ inputs.recipe_id_latest }} -r cura-ce -f || true
+      - name: Export the Package
+        if: ${{ !inputs.conan_export_binaries }}
+        run: conan export . ${{ inputs.recipe_id_full }}
 
-            -   name: Create the latest alias
-                if: ${{ inputs.recipe_id_latest != '' && always() }}
-                run: conan alias ${{ inputs.recipe_id_latest }} ${{ inputs.recipe_id_full }}
+      - name: Create the latest alias
+        if: always()
+        run: conan alias ${{ inputs.recipe_id_latest }} ${{ inputs.recipe_id_full }}
 
-            -   name: Upload the Package(s)
-                if: always()
-                run: conan upload "*" -r cura --all -c
+      - name: Upload the Package(s)
+        if: ${{ always() && inputs.conan_upload_community }}
+        run: |
+          conan upload ${{ inputs.recipe_id_full }} -r cura --all -c
+          conan upload ${{ inputs.recipe_id_latest }} -r cura -c
 
-            -   name: Upload the Package(s) community
-                if: ${{ always() && inputs.conan_upload_community == true }}
-                run: conan upload "*" -r cura-ce -c
+      - name: Upload the Package(s) to the private Artifactory
+        if: ${{ always() && ! inputs.conan_upload_community }}
+        run: |
+          conan upload ${{ inputs.recipe_id_full }} -r cura-private --all -c
+          conan upload ${{ inputs.recipe_id_latest }} -r cura-private -c

.github/workflows/conan-recipe-version.yml

@@ -7,6 +7,11 @@ on:
                 required: true
                 type: string
 
+            user:
+                required: false
+                default: ultimaker
+                type: string
+
             additional_buildmetadata:
                 required: false
                 default: ""
@@ -72,7 +77,7 @@ jobs:
             -   name: Setup Python and pip
                 uses: actions/setup-python@v4
                 with:
-                    python-version: "3.10.x"
+                    python-version: "3.11.x"
                     cache: 'pip'
                     cache-dependency-path: .github/workflows/requirements-conan-package.txt
 
@@ -86,12 +91,12 @@ jobs:
                 run: |
                     import subprocess
                     import os
-                    from conans import tools
-                    from conans.errors import ConanException
+                    from conan.tools.scm import Version
+                    from conan.errors import ConanException
                     from git import Repo
                     
                     repo = Repo('.')
-                    user = "${{ github.repository_owner }}".lower()
+                    user = "${{ inputs.user }}".lower()
                     project_name = "${{ inputs.project_name }}"
                     event_name = "${{ github.event_name }}"
                     issue_number = "${{ github.ref }}".split('/')[2]
@@ -103,16 +108,16 @@ jobs:
                     # FIXME: for when we push a tag (such as an release)
                     channel = "testing"
                     if is_tag:
-                        branch_version = tools.Version(ref_name)
+                        branch_version = Version(ref_name)
                         is_release_branch = True
                         channel = "_"
                         user = "_"
                         actual_version = f"{branch_version}"
                     else:
                         try:
-                            branch_version = tools.Version(repo.active_branch.name)
+                            branch_version = Version(repo.active_branch.name)
                         except ConanException:
-                            branch_version = tools.Version('0.0.0')
+                            branch_version = Version('0.0.0')
                         if ref_name == f"{branch_version.major}.{branch_version.minor}":
                             channel = 'stable'
                             is_release_branch = True
@@ -125,66 +130,62 @@ jobs:
                             channel = f"pr_{issue_number}"
                     
                         # %% Get the actual version
-                        latest_branch_version = tools.Version("0.0.0")
+                        latest_branch_version = Version("0.0.0")
                         latest_branch_tag = None
-                        for tag in repo.git.tag(merged = True).splitlines():
+                        for tag in repo.active_branch.repo.tags:
                             if str(tag).startswith("firmware") or str(tag).startswith("master"):
                                 continue  # Quick-fix for the versioning scheme name of the embedded team in fdm_materials(_private) repo
                             try:
-                                version = tools.Version(tag)
+                                version = Version(tag)
                             except ConanException:
                                 continue
-                            if version > latest_branch_version and version < tools.Version("10.0.0"):
-                                # FIXME: stupid old Cura tags 13.04 etc. keep popping up
+                            if version > latest_branch_version and version < Version("6.0.0"):
+                                # FIXME: stupid old Cura tags 13.04 etc. keep popping up, als  the fdm_material tag for firmware are messing with this
                                 latest_branch_version = version
                                 latest_branch_tag = repo.tag(tag)
                         
                         if latest_branch_tag:
                             # %% Get the actual version
-                            no_commits = 0
-                            for commit in repo.iter_commits("HEAD"):
-                                if commit == latest_branch_tag.commit:
-                                    break
-                                no_commits += 1
-                            latest_branch_version_prerelease = latest_branch_version.prerelease
-                            if latest_branch_version.prerelease and not "." in latest_branch_version.prerelease:
+                            sha_commit = repo.commit().hexsha[:6]
+                            latest_branch_version_prerelease = latest_branch_version.pre
+                            if latest_branch_version.pre and not "." in str(latest_branch_version.pre):
                                 # The prerealese did not contain a version number, default it to 1
-                                latest_branch_version_prerelease = f"{latest_branch_version.prerelease}.1"
+                                latest_branch_version_prerelease = f"{latest_branch_version.pre}.1"
                             if event_name == "pull_request":
-                                actual_version = f"{latest_branch_version.major}.{latest_branch_version.minor}.{latest_branch_version.patch}-{latest_branch_version_prerelease.lower()}+{buildmetadata}pr_{issue_number}_{no_commits}"
-                                channel_metadata = f"{channel}_{no_commits}"
+                                actual_version = f"{latest_branch_version.major}.{latest_branch_version.minor}.{latest_branch_version.patch}-{str(latest_branch_version_prerelease).lower()}+{buildmetadata}pr_{issue_number}_{sha_commit}"
+                                channel_metadata = f"{channel}_{sha_commit}"
                             else:
                                 if channel in ("stable", "_", ""):
-                                    channel_metadata = f"{no_commits}"
+                                    channel_metadata = f"{sha_commit}"
                                 else:
-                                    channel_metadata = f"{channel}_{no_commits}"
+                                    channel_metadata = f"{channel}_{sha_commit}"
                             if is_release_branch:
-                                if latest_branch_version.prerelease == "" and branch_version > latest_branch_version:
+                                if (latest_branch_version.pre == "" or latest_branch_version.pre is None) and branch_version > latest_branch_version:
                                     actual_version = f"{branch_version.major}.{branch_version.minor}.0-beta.1+{buildmetadata}{channel_metadata}"
-                                elif latest_branch_version.prerelease == "":
+                                elif latest_branch_version.pre == "":
                                     # An actual full release has been created, we are working on patch
-                                    bump_up_patch = int(latest_branch_version.patch) + 1
+                                    bump_up_patch = int(str(latest_branch_version.patch)) + 1
                                     actual_version = f"{latest_branch_version.major}.{latest_branch_version.minor}.{bump_up_patch}-beta.1+{buildmetadata}{channel_metadata}"
+                                elif latest_branch_version.pre is None:
+                                    actual_version = f"{latest_branch_version.major}.{latest_branch_version.minor}.{int(latest_branch_version.patch.value) + 1}-beta.1+{buildmetadata}{channel_metadata}"
                                 else:
                                     # An beta release has been created we are working toward a next beta or full release
-                                    bump_up_release_tag = int(latest_branch_version.prerelease.split('.')[1]) + 1
-                                    actual_version = f"{latest_branch_version.major}.{latest_branch_version.minor}.{latest_branch_version.patch}-{latest_branch_version.prerelease.split('.')[0]}.{bump_up_release_tag}+{buildmetadata}{channel_metadata}"
+                                    bump_up_release_tag = int(str(latest_branch_version.pre).split('.')[1]) + 1
+                                    actual_version = f"{latest_branch_version.major}.{latest_branch_version.minor}.{latest_branch_version.patch}-{str(latest_branch_version.pre).split('.')[0]}.{bump_up_release_tag}+{buildmetadata}{channel_metadata}"
                             else:
-                                max_branches_version = tools.Version("0.0.0")
-                                branches_no_commits = no_commits
+                                max_branches_version = Version("0.0.0")
                                 for branch in repo.references:
                                     try:
                                         if "remotes/origin" in branch.abspath:
-                                            b_version = tools.Version(branch.name.split("/")[-1])
-                                            if b_version < tools.Version("10.0.0") and b_version > max_branches_version:
+                                            b_version = Version(branch.name.split("/")[-1])
+                                            if b_version <  Version("6.0.0") and b_version > max_branches_version:
                                                 max_branches_version = b_version
-                                                branches_no_commits = repo.commit().count() - branch.commit.count()
                                     except:
                                         pass
                                 if max_branches_version > latest_branch_version:
-                                    actual_version = f"{max_branches_version.major}.{int(max_branches_version.minor) + 1}.0-alpha+{buildmetadata}{channel}_{branches_no_commits}"
+                                    actual_version = f"{max_branches_version.major}.{int(str(max_branches_version.minor)) + 1}.0-alpha+{buildmetadata}{channel}_{sha_commit}"
                                 else:
-                                    actual_version = f"{latest_branch_version.major}.{int(latest_branch_version.minor) + 1}.0-alpha+{buildmetadata}{channel_metadata}"
+                                    actual_version = f"{latest_branch_version.major}.{int(str(latest_branch_version.minor)) + 1}.0-alpha+{buildmetadata}{channel_metadata}"
 
                     # %% Set the environment output
                     output_env = os.environ["GITHUB_OUTPUT"]
@@ -203,14 +204,14 @@ jobs:
                         f.writelines(f"semver_full={actual_version}\n")
                         f.writelines(f"is_release_branch={str(is_release_branch).lower()}\n")
                     
-                    print("::group::Conan Recipe Information")
-                    print(f"name = {project_name}")
-                    print(f"version = {actual_version}")
-                    print(f"user = {user}")
-                    print(f"channel = {channel}")
-                    print(f"recipe_id_full = {project_name}/{actual_version}@{user}/{channel}")
-                    print(f"recipe_id_latest = {project_name}/latest@{user}/{channel}")
-                    print(f"semver_full = {actual_version}")
-                    print(f"is_release_branch = {str(is_release_branch).lower()}")
-                    print("::endgroup::")
+                    summary_env = os.environ["GITHUB_STEP_SUMMARY"]
+                    with open(summary_env, "w") as f:
+                        f.writelines(f"# {project_name}\n")
+                        f.writelines(f"name={project_name}\n")
+                        f.writelines(f"version={actual_version}\n")
+                        f.writelines(f"channel={channel}\n")
+                        f.writelines(f"recipe_id_full={project_name}/{actual_version}@{user}/{channel}\n")
+                        f.writelines(f"recipe_id_latest={project_name}/latest@{user}/{channel}\n")
+                        f.writelines(f"semver_full={actual_version}\n")
+                        f.writelines(f"is_release_branch={str(is_release_branch).lower()}\n")
                 shell: python

.github/workflows/cura-all-installers.yml

@@ -1,151 +0,0 @@
-name: Cura All Installers
-run-name: ${{ inputs.cura_conan_version }} for exe ${{ inputs.build_windows_exe }}, msi ${{ inputs.build_windows_msi }}, dmg ${{ inputs.build_macos }}, pkg ${{ inputs.build_macos_installer }}, appimage ${{ inputs.build_linux }} - enterprise ${{ inputs.enterprise }}
-
-on:
-    workflow_dispatch:
-        inputs:
-            cura_conan_version:
-                description: 'Cura Conan Version'
-                default: 'cura/latest@ultimaker/testing'
-                required: true
-                type: string
-            conan_args:
-                description: 'Conan args: eq.: --require-override'
-                default: ''
-                required: false
-                type: string
-            conan_config:
-                description: 'Conan config branch to use'
-                default: ''
-                required: false
-                type: string
-            enterprise:
-                description: 'Build Cura as an Enterprise edition'
-                default: false
-                required: true
-                type: boolean
-            staging:
-                description: 'Use staging API'
-                default: false
-                required: true
-                type: boolean
-            installer:
-                description: 'Create the installer'
-                default: true
-                required: true
-                type: boolean
-            build_windows_exe:
-                description: 'Build for Windows exe'
-                default: false
-                required: true
-                type: boolean
-            build_windows_msi:
-                description: 'Build for msi+pkg'
-                default: true
-                required: true
-                type: boolean
-            build_linux:
-                description: 'Build for Linux'
-                default: true
-                required: true
-                type: boolean
-            build_macos:
-                description: 'Build dmg for MacOS'
-                default: true
-                required: true
-                type: boolean
-
-    # Run the nightly at 3:25 UTC on working days
-    schedule:
-    - cron: '25 3 * * 1-5'
-
-jobs:
-    windows-installer-create-exe:
-        if: ${{ inputs.build_windows_exe }}
-        uses: ./.github/workflows/cura-installer.yml
-        with:
-            platform: 'windows-2022'
-            os_name: 'win64'
-            cura_conan_version: ${{ inputs.cura_conan_version }}
-            conan_args: ${{ inputs.conan_args }}
-            conan_config: ${{ inputs.conan_config }}
-            enterprise: ${{ inputs.enterprise }}
-            staging: ${{ inputs.staging }}
-            installer: ${{ inputs.installer }}
-            msi_installer: false
-        secrets: inherit
-
-    windows-installer-create-msi:
-        if: ${{ inputs.build_windows_msi }}
-        uses: ./.github/workflows/cura-installer.yml
-        with:
-            platform: 'windows-2022'
-            os_name: 'win64'
-            cura_conan_version: ${{ inputs.cura_conan_version }}
-            conan_args: ${{ inputs.conan_args }}
-            conan_config: ${{ inputs.conan_config }}
-            enterprise: ${{ inputs.enterprise }}
-            staging: ${{ inputs.staging }}
-            installer: ${{ inputs.installer }}
-            msi_installer: true
-        secrets: inherit
-
-    linux-installer-create:
-        if: ${{ inputs.build_linux }}
-        uses: ./.github/workflows/cura-installer.yml
-        with:
-            platform: 'ubuntu-20.04'
-            os_name: 'linux'
-            cura_conan_version: ${{ inputs.cura_conan_version }}
-            conan_args: ${{ inputs.conan_args }}
-            conan_config: ${{ inputs.conan_config }}
-            enterprise: ${{ inputs.enterprise }}
-            staging: ${{ inputs.staging }}
-            installer: ${{ inputs.installer }}
-            msi_installer: false
-        secrets: inherit
-
-    linux-modern-installer-create:
-        if: ${{ inputs.build_linux }}
-        uses: ./.github/workflows/cura-installer.yml
-        with:
-            platform: 'ubuntu-22.04'
-            os_name: 'linux-modern'
-            cura_conan_version: ${{ inputs.cura_conan_version }}
-            conan_args: ${{ inputs.conan_args }}
-            conan_config: ${{ inputs.conan_config }}
-            enterprise: ${{ inputs.enterprise }}
-            staging: ${{ inputs.staging }}
-            installer: ${{ inputs.installer }}
-            msi_installer: false
-        secrets: inherit
-
-    macos-dmg-create:
-        if: ${{ inputs.build_macos }}
-        uses: ./.github/workflows/cura-installer.yml
-        with:
-            platform: 'macos-11'
-            os_name: 'mac'
-            cura_conan_version: ${{ inputs.cura_conan_version }}
-            conan_args: ${{ inputs.conan_args }}
-            conan_config: ${{ inputs.conan_config }}
-            enterprise: ${{ inputs.enterprise }}
-            staging: ${{ inputs.staging }}
-            installer: ${{ inputs.installer }}
-            msi_installer: false
-        secrets: inherit
-
-    macos-installer-create:
-        if: ${{ inputs.build_macos }}
-        uses: ./.github/workflows/cura-installer.yml
-        with:
-            platform: 'macos-11'
-            os_name: 'mac'
-            cura_conan_version: ${{ inputs.cura_conan_version }}
-            conan_args: ${{ inputs.conan_args }}
-            conan_config: ${{ inputs.conan_config }}
-            enterprise: ${{ inputs.enterprise }}
-            staging: ${{ inputs.staging }}
-            installer: ${{ inputs.installer }}
-            msi_installer: true
-        secrets: inherit

.github/workflows/cura-installer.yml

@@ -1,338 +0,0 @@
-name: Cura Installer
-run-name: ${{ inputs.cura_conan_version }} for ${{ inputs.platform }} by @${{ github.actor }}
-
-on:
-    workflow_call:
-        inputs:
-            platform:
-                description: 'Selected Installer OS'
-                default: 'ubuntu-20.04'
-                required: true
-                type: string
-            os_name:
-                description: 'OS Friendly Name'
-                default: 'linux'
-                required: true
-                type: string
-            cura_conan_version:
-                description: 'Cura Conan Version'
-                default: 'cura/latest@ultimaker/testing'
-                required: true
-                type: string
-            conan_args:
-                description: 'Conan args: eq.: --require-override'
-                default: ''
-                required: false
-                type: string
-            conan_config:
-                description: 'Conan config branch to use'
-                default: ''
-                required: false
-                type: string
-            enterprise:
-                description: 'Build Cura as an Enterprise edition'
-                default: false
-                required: true
-                type: boolean
-            staging:
-                description: 'Use staging API'
-                default: false
-                required: true
-                type: boolean
-            installer:
-                description: 'Create the installer'
-                default: true
-                required: true
-                type: boolean
-            msi_installer:
-                description: 'Create the msi'
-                default: false
-                required: true
-                type: boolean
-
-env:
-    CONAN_LOGIN_USERNAME_CURA: ${{ secrets.CONAN_USER }}
-    CONAN_PASSWORD_CURA: ${{ secrets.CONAN_PASS }}
-    CONAN_LOGIN_USERNAME_CURA_CE: ${{ secrets.CONAN_USER }}
-    CONAN_PASSWORD_CURA_CE: ${{ secrets.CONAN_PASS }}
-    CONAN_LOG_RUN_TO_OUTPUT: 1
-    CONAN_LOGGING_LEVEL: ${{ inputs.conan_logging_level }}
-    CONAN_NON_INTERACTIVE: 1
-    CODESIGN_IDENTITY: ${{ secrets.CODESIGN_IDENTITY }}
-    MAC_NOTARIZE_USER: ${{ secrets.MAC_NOTARIZE_USER }}
-    MAC_NOTARIZE_PASS: ${{ secrets.MAC_NOTARIZE_PASS }}
-    MACOS_CERT_P12: ${{ secrets.MACOS_CERT_P12 }}
-    MACOS_CERT_INSTALLER_P12: ${{ secrets.MACOS_CERT_INSTALLER_P12 }}
-    MACOS_CERT_USER: ${{ secrets.MACOS_CERT_USER }}
-    GPG_PRIVATE_KEY: ${{ secrets.GPG_PRIVATE_KEY }}
-    MACOS_CERT_PASSPHRASE: ${{ secrets.MACOS_CERT_PASSPHRASE }}
-    WIN_CERT_INSTALLER_CER: ${{ secrets.WIN_CERT_INSTALLER_CER }}
-    WIN_CERT_INSTALLER_CER_PASS: ${{ secrets.WIN_CERT_INSTALLER_CER_PASS }}
-    CURA_CONAN_VERSION: ${{ inputs.cura_conan_version }}
-    ENTERPRISE: ${{ inputs.enterprise }}
-    STAGING: ${{ inputs.staging }}
-
-jobs:
-    cura-installer-create:
-        runs-on: ${{ inputs.platform }}
-
-        steps:
-            -   name: Checkout
-                uses: actions/checkout@v3
-
-            -   name: Setup Python and pip
-                uses: actions/setup-python@v4
-                with:
-                    python-version: '3.10.x'
-                    cache: 'pip'
-                    cache-dependency-path: .github/workflows/requirements-conan-package.txt
-
-            -   name: Install Python requirements for runner
-                run: pip install -r https://raw.githubusercontent.com/Ultimaker/Cura/main/.github/workflows/requirements-conan-package.txt
-                #  Note the runner requirements are always installed from the main branch in the Ultimaker/Cura repo
-
-            -   name: Use Conan download cache (Bash)
-                if: ${{ runner.os != 'Windows' }}
-                run: conan config set storage.download_cache="$HOME/.conan/conan_download_cache"
-
-            -   name: Use Conan download cache (Powershell)
-                if: ${{ runner.os == 'Windows' }}
-                run: conan config set storage.download_cache="C:\Users\runneradmin\.conan\conan_download_cache"
-
-            -   name: Cache Conan local repository packages (Bash)
-                uses: actions/cache@v3
-                if: ${{ runner.os != 'Windows' }}
-                with:
-                    path: |
-                        $HOME/.conan/data
-                        $HOME/.conan/conan_download_cache
-                    key: conan-${{ runner.os }}-${{ runner.arch }}-installer-cache
-
-            -   name: Cache Conan local repository packages (Powershell)
-                uses: actions/cache@v3
-                if: ${{ runner.os == 'Windows' }}
-                with:
-                    path: |
-                        C:\Users\runneradmin\.conan\data
-                        C:\.conan
-                        C:\Users\runneradmin\.conan\conan_download_cache
-                    key: conan-${{ runner.os }}-${{ runner.arch }}-installer-cache
-
-            -   name: Install MacOS system requirements
-                if:  ${{ runner.os == 'Macos' }}
-                run: brew install autoconf automake ninja create-dmg # Delete create-dmg when deprecating dmg
-
-            -   name: Install Linux system requirements
-                if: ${{ runner.os == 'Linux' }}
-                run: |
-                    sudo add-apt-repository ppa:ubuntu-toolchain-r/test -y
-                    sudo apt update
-                    sudo apt upgrade
-                    sudo apt install build-essential checkinstall libegl-dev zlib1g-dev libssl-dev ninja-build autoconf libx11-dev libx11-xcb-dev libfontenc-dev libice-dev libsm-dev libxau-dev libxaw7-dev libxcomposite-dev libxcursor-dev libxdamage-dev libxdmcp-dev libxext-dev libxfixes-dev libxi-dev libxinerama-dev libxkbfile-dev libxmu-dev libxmuu-dev libxpm-dev libxrandr-dev libxrender-dev libxres-dev libxss-dev libxt-dev libxtst-dev libxv-dev libxvmc-dev libxxf86vm-dev xtrans-dev libxcb-render0-dev libxcb-render-util0-dev libxcb-xkb-dev libxcb-icccm4-dev libxcb-image0-dev libxcb-keysyms1-dev libxcb-randr0-dev libxcb-shape0-dev libxcb-sync-dev libxcb-xfixes0-dev libxcb-xinerama0-dev xkb-data libxcb-dri3-dev uuid-dev libxcb-util-dev libxkbcommon-x11-dev pkg-config -y
-                    wget --no-check-certificate --quiet https://github.com/AppImage/AppImageKit/releases/download/continuous/appimagetool-x86_64.AppImage -O $GITHUB_WORKSPACE/appimagetool
-                    chmod +x $GITHUB_WORKSPACE/appimagetool
-                    echo "APPIMAGETOOL_LOCATION=$GITHUB_WORKSPACE/appimagetool" >> $GITHUB_ENV
-
-            -   name: Install GCC-12 on ubuntu-22.04
-                if: ${{ startsWith(inputs.platform, 'ubuntu-22.04') }}
-                run: |
-                    sudo apt install g++-12 gcc-12 -y
-                    sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-12 12
-                    sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-12 12
-
-            -   name: Use GCC-10 on ubuntu-20.04
-                if: ${{ startsWith(inputs.platform, 'ubuntu-20.04') }}
-                run: |
-                    sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-10 10
-                    sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-10 10
-
-            -   name: Create the default Conan profile
-                run:  conan profile new default --detect
-
-            -   name: Configure GPG Key Linux (Bash)
-                if: ${{ runner.os == 'Linux' }}
-                run: echo -n "$GPG_PRIVATE_KEY" | base64 --decode | gpg --import
-
-            -   name: Configure Macos keychain Developer Cert(Bash)
-                id: macos-keychain-developer-cert
-                if: ${{ runner.os == 'Macos' }}
-                uses: apple-actions/import-codesign-certs@v1
-                with:
-                    keychain-password: ${{ secrets.MACOS_KEYCHAIN_PASSWORD }}
-                    p12-file-base64: ${{ secrets.MACOS_CERT_P12 }}
-                    p12-password: ${{ secrets.MACOS_CERT_PASSPHRASE }}
-
-            -   name: Configure Macos keychain Installer Cert (Bash)
-                id: macos-keychain-installer-cert
-                if: ${{ runner.os == 'Macos' }}
-                uses: apple-actions/import-codesign-certs@v1
-                with:
-                    keychain-password: ${{ secrets.MACOS_KEYCHAIN_PASSWORD }}
-                    create-keychain: false # keychain is created in previous use of action.
-                    p12-file-base64: ${{ secrets.MACOS_CERT_INSTALLER_P12 }}
-                    p12-password: ${{ secrets.MACOS_CERT_PASSPHRASE }}
-
-            -   name: Create PFX certificate from BASE64_PFX_CONTENT secret
-                if: ${{ runner.os == 'Windows' }}
-                id: create-pfx
-                env:
-                    PFX_CONTENT: ${{ secrets.WIN_CERT_INSTALLER_CER }}
-                run: |
-                    $pfxPath = Join-Path -Path $env:RUNNER_TEMP -ChildPath "cert.pfx"; 
-                    $encodedBytes = [System.Convert]::FromBase64String($env:PFX_CONTENT); 
-                    Set-Content $pfxPath -Value $encodedBytes -AsByteStream;
-                    echo "PFX_PATH=$pfxPath" >> $env:GITHUB_OUTPUT;
-
-            -   name: Get Conan configuration from branch
-                if: ${{ inputs.conan_config != '' }}
-                run: conan config install https://github.com/Ultimaker/conan-config.git -a "-b ${{ inputs.conan_config }}"
-
-            -   name: Get Conan configuration
-                if: ${{ inputs.conan_config == '' }}
-                run: conan config install https://github.com/Ultimaker/conan-config.git
-
-            -   name: Create the Packages (Bash)
-                if: ${{ runner.os != 'Windows' }}
-                run: conan install $CURA_CONAN_VERSION ${{ inputs.conan_args }} --build=missing --update -if cura_inst -g VirtualPythonEnv -o cura:enterprise=$ENTERPRISE -o cura:staging=$STAGING --json "cura_inst/conan_install_info.json"
-
-            -   name: Create the Packages (Powershell)
-                if: ${{ runner.os == 'Windows' }}
-                run: conan install $Env:CURA_CONAN_VERSION ${{ inputs.conan_args }} --build=missing --update -if cura_inst -g VirtualPythonEnv -o cura:enterprise=$Env:ENTERPRISE -o cura:staging=$Env:STAGING --json "cura_inst/conan_install_info.json"
-
-            -   name: Set Environment variables for Cura (bash)
-                if: ${{ runner.os != 'Windows' }}
-                run: |
-                    . ./cura_inst/bin/activate_github_actions_env.sh
-                    . ./cura_inst/bin/activate_github_actions_version_env.sh
-
-            -   name: Set Environment variables for Cura (Powershell)
-                if: ${{ runner.os == 'Windows' }}
-                run: |
-                    echo "${Env:WIX}\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
-                    .\cura_inst\Scripts\activate_github_actions_env.ps1
-                    .\cura_inst\Scripts\activate_github_actions_version_env.ps1
-
-            -   name: Unlock Macos keychain (Bash)
-                if: ${{ runner.os == 'Macos' }}
-                run: security unlock -p $TEMP_KEYCHAIN_PASSWORD signing_temp.keychain
-                env:
-                    TEMP_KEYCHAIN_PASSWORD: ${{  steps.macos-keychain-developer-cert.outputs.keychain-password }}
-
-                # FIXME: This is a workaround to ensure that we use and pack a shared library for OpenSSL 1.1.1l. We currently compile
-                #  OpenSSL statically for CPython, but our Python Dependenies (such as PyQt6) require a shared library.
-                #  Because Conan won't allow for building the same library with two different options (easily) we need to install it explicitly
-                #  and do a manual copy to the VirtualEnv, such that Pyinstaller can find it.
-
-            -   name: Install OpenSSL shared
-                run: conan install openssl/1.1.1l@_/_ --build=missing --update -o openssl:shared=True -g deploy
-
-            -   name: Copy OpenSSL shared (Bash)
-                if: ${{ runner.os != 'Windows' }}
-                run: |
-                    cp ./openssl/lib/*.so* ./cura_inst/bin/ || true
-                    cp ./openssl/lib/*.dylib* ./cura_inst/bin/ || true                    
-
-            -   name: Copy OpenSSL shared (Powershell)
-                if: ${{ runner.os == 'Windows' }}
-                run: |
-                    cp openssl/bin/*.dll ./cura_inst/Scripts/
-                    cp openssl/lib/*.lib ./cura_inst/Lib/
-
-            -   name: Create the Cura dist
-                run: pyinstaller ./cura_inst/UltiMaker-Cura.spec
-
-            -   name: Output the name file name and extension
-                id: filename
-                shell: python
-                run: |
-                    import os
-                    enterprise = "-Enterprise" if "${{ inputs.enterprise }}" == "true" else ""
-                    installer_filename = f"UltiMaker-Cura-{os.getenv('CURA_VERSION_FULL')}{enterprise}-${{ inputs.os_name }}"
-                    if "${{ runner.os }}" == "Windows":
-                        installer_ext = "msi" if "${{ inputs.msi_installer }}" == "true" else "exe"
-                    elif "${{ runner.os }}" == "macOS":
-                        installer_ext = "pkg" if "${{ inputs.msi_installer }}" == "true" else "dmg"
-                    else:
-                        installer_ext = "AppImage"
-                    output_env = os.environ["GITHUB_OUTPUT"]
-                    content = ""
-                    if os.path.exists(output_env):
-                        with open(output_env, "r") as f:
-                            content = f.read()
-                    with open(output_env, "w") as f:
-                        f.write(content)
-                        f.writelines(f"INSTALLER_FILENAME={installer_filename}\n")
-                        f.writelines(f"INSTALLER_EXT={installer_ext}\n")
-                        f.writelines(f"FULL_INSTALLER_FILENAME={installer_filename}.{installer_ext}\n")
-
-            -   name: Archive the artifacts (bash)
-                if: ${{ !inputs.installer && runner.os != 'Windows' }}
-                run: tar -zcf "./${{ steps.filename.outputs.INSTALLER_FILENAME }}.tar.gz" "./UltiMaker-Cura/"
-                working-directory: dist
-
-            -   name: Archive the artifacts (Powershell)
-                if: ${{ !inputs.installer && runner.os == 'Windows' }}
-                run: Compress-Archive -Path ".\UltiMaker-Cura" -DestinationPath ".\${{ steps.filename.outputs.INSTALLER_FILENAME }}.zip"
-                working-directory: dist
-
-            -   name: Create the Windows exe installer (Powershell)
-                if: ${{ inputs.installer && runner.os == 'Windows' && !inputs.msi_installer }}
-                run: |
-                    python ..\cura_inst\packaging\NSIS\create_windows_installer.py ../cura_inst . "${{ steps.filename.outputs.FULL_INSTALLER_FILENAME }}"
-                working-directory: dist
-
-            -   name: Create the Windows msi installer (Powershell)
-                if: ${{ inputs.installer && runner.os == 'Windows' && inputs.msi_installer }}
-                run: |
-                    python ..\cura_inst\packaging\msi\create_windows_msi.py ..\cura_inst .\UltiMaker-Cura "${{ steps.filename.outputs.FULL_INSTALLER_FILENAME }}" "$Env:CURA_APP_NAME"
-                working-directory: dist
-
-            -   name: Sign the Windows exe installer (Powershell)
-                if: ${{ inputs.installer && runner.os == 'Windows' && !inputs.msi_installer }}
-                env:
-                    PFX_PATH: ${{ steps.create-pfx.outputs.PFX_PATH }}
-                run: |
-                    & "C:/Program Files (x86)/Windows Kits/10/bin/10.0.17763.0/x86/signtool.exe" sign /f $Env:PFX_PATH /p "$Env:WIN_CERT_INSTALLER_CER_PASS" /fd SHA256 /t http://timestamp.digicert.com "${{ steps.filename.outputs.FULL_INSTALLER_FILENAME }}"
-                working-directory: dist
-
-            -   name: Sign the Windows msi installer (Powershell)
-                if: ${{ inputs.installer && runner.os == 'Windows' && inputs.msi_installer }}
-                env:
-                    PFX_PATH: ${{ steps.create-pfx.outputs.PFX_PATH }}
-                run: |
-                    & "C:/Program Files (x86)/Windows Kits/10/bin/10.0.17763.0/x86/signtool.exe" sign /f $Env:PFX_PATH /p "$Env:WIN_CERT_INSTALLER_CER_PASS" /fd SHA256 /t http://timestamp.digicert.com "${{ steps.filename.outputs.FULL_INSTALLER_FILENAME }}"
-                working-directory: dist
-
-            -   name: Create the Linux AppImage (Bash)
-                if: ${{ inputs.installer && runner.os == 'Linux' }}
-                run: python ../cura_inst/packaging/AppImage/create_appimage.py ./UltiMaker-Cura $CURA_VERSION_FULL "${{ steps.filename.outputs.FULL_INSTALLER_FILENAME }}"
-                working-directory: dist
-
-            -   name: Create the MacOS dmg and/or pkg (Bash)
-                if: ${{ github.event.inputs.installer == 'true' && runner.os == 'Macos' }}
-                run: python ../cura_inst/packaging/MacOS/build_macos.py ../cura_inst . $CURA_CONAN_VERSION "${{ steps.filename.outputs.FULL_INSTALLER_FILENAME }}" "$CURA_APP_NAME"
-                working-directory: dist
-
-            -   name: Upload the artifacts
-                uses: actions/upload-artifact@v3
-                with:
-                    name: ${{ steps.filename.outputs.INSTALLER_FILENAME }}-${{ steps.filename.outputs.INSTALLER_EXT }}
-                    path: |
-                        dist/*.tar.gz
-                        dist/*.zip
-                        dist/${{ steps.filename.outputs.FULL_INSTALLER_FILENAME }}
-                        dist/*.asc
-                    retention-days: 5
-
-    notify-export:
-        if: ${{ always() }}
-        needs: [ cura-installer-create ]
-
-        uses: ultimaker/cura/.github/workflows/notify.yml@main
-        with:
-            success: ${{ contains(join(needs.*.result, ','), 'success') }}
-            success_title: "Create the Cura distributions"
-            success_body: "Installers for ${{ inputs.cura_conan_version }}"
-            failure_title: "Failed to create the Cura distributions"
-            failure_body: "Failed to create at least 1 installer for ${{ inputs.cura_conan_version }}"
-        secrets: inherit

.github/workflows/installers.yml

@@ -0,0 +1,267 @@
+name: All installers
+run-name: ${{ inputs.cura_conan_version }} by @${{ github.actor }}
+
+on:
+  workflow_dispatch:
+    inputs:
+      cura_conan_version:
+        description: 'Cura Conan Version'
+        default: 'cura/latest@ultimaker/testing'
+        required: true
+        type: string
+      conan_args:
+        description: 'Conan args: eq.: --require-override'
+        default: ''
+        required: false
+        type: string
+      enterprise:
+        description: 'Build Cura as an Enterprise edition'
+        default: false
+        required: true
+        type: boolean
+      staging:
+        description: 'Use staging API'
+        default: false
+        required: true
+        type: boolean
+      nightly:
+        description: 'Upload to nightly release'
+        default: false
+        required: true
+        type: boolean
+
+  schedule:
+    # Daily at 5:15 CET
+    - cron: '15 3 * * *'
+
+env:
+  CURA_CONAN_VERSION: ${{ inputs.cura_conan_version || 'cura/latest@ultimaker/testing' }}
+  CONAN_ARGS: ${{ inputs.conan_args || '' }}
+  ENTERPRISE: ${{ inputs.enterprise || false }}
+  STAGING: ${{ inputs.staging || false }}
+
+jobs:
+  default-values:
+    runs-on: ubuntu-latest
+    outputs:
+      cura_conan_version: ${{ steps.default.outputs.cura_conan_version  }}
+
+    steps:
+    - name: Output default values
+      id: default
+      shell: python
+      run: |
+        import os
+        cura_conan_version = "cura/latest@ultimaker/testing" if "${{ github.event.inputs.cura_conan_version }}" == "" else "${{ github.event.inputs.cura_conan_version }}" 
+        output_env = os.environ["GITHUB_OUTPUT"]
+        content = ""
+        if os.path.exists(output_env):
+            with open(output_env, "r") as f:
+                content = f.read()
+        with open(output_env, "w") as f:
+            f.write(content)
+            f.writelines(f"cura_conan_version={cura_conan_version}\n")
+
+  windows-installer:
+    uses: ./.github/workflows/windows.yml
+    needs: [ default-values ]
+    with:
+      cura_conan_version: ${{ needs.default-values.outputs.cura_conan_version }}
+      conan_args: ${{ github.event.inputs.conan_args }}
+      enterprise: ${{ github.event.inputs.enterprise == 'true' }}
+      staging: ${{ github.event.inputs.staging == 'true' }}
+      architecture: X64
+      operating_system: windows-2022
+    secrets: inherit
+
+  linux-installer:
+    uses: ./.github/workflows/linux.yml
+    needs: [ default-values ]
+    with:
+      cura_conan_version: ${{ needs.default-values.outputs.cura_conan_version }}
+      conan_args: ${{ github.event.inputs.conan_args }}
+      enterprise: ${{ github.event.inputs.enterprise == 'true' }}
+      staging: ${{ github.event.inputs.staging == 'true' }}
+      architecture: X64
+      operating_system: ubuntu-22.04
+    secrets: inherit
+
+  macos-installer:
+    uses: ./.github/workflows/macos.yml
+    needs: [ default-values ]
+    with:
+      cura_conan_version: ${{ needs.default-values.outputs.cura_conan_version }}
+      conan_args: ${{ github.event.inputs.conan_args }}
+      enterprise: ${{ github.event.inputs.enterprise == 'true' }}
+      staging: ${{ github.event.inputs.staging == 'true' }}
+      architecture: X64
+      operating_system: macos-11.0
+    secrets: inherit
+
+  macos-arm-installer:
+    uses: ./.github/workflows/macos.yml
+    needs: [ default-values ]
+    with:
+      cura_conan_version: ${{ needs.default-values.outputs.cura_conan_version }}
+      conan_args: ${{ github.event.inputs.conan_args }}
+      enterprise: ${{ github.event.inputs.enterprise == 'true' }}
+      staging: ${{ github.event.inputs.staging == 'true' }}
+      architecture: ARM64
+      operating_system: self-hosted
+    secrets: inherit
+
+  # Run and update nightly release when the nightly input is set to true or if the schedule is triggered
+  update-nightly-release:
+    if: ${{ inputs.nightly || github.event_name == 'schedule' }}
+    runs-on: ubuntu-latest
+    needs: [ windows-installer, linux-installer, macos-installer, macos-arm-installer ]
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+
+      # It's not necessary to download all three, but it does make sure we have at least one if an OS is skipped.
+
+      - name: Download the run info
+        uses: actions/download-artifact@v2
+        with:
+          name: linux-run-info
+
+      - name: Set the run info as environment variables
+        run: |
+          . run_info.sh 
+
+      - name: Output the name file name and extension
+        id: filename
+        shell: python
+        run: |
+          import os
+          import datetime
+          enterprise = "-Enterprise" if "${{ github.event.inputs.enterprise }}" == "true" else ""
+          linux = f"UltiMaker-Cura-{os.getenv('CURA_VERSION_FULL')}{enterprise}-linux-X64"
+          mac_x64_dmg = f"UltiMaker-Cura-{os.getenv('CURA_VERSION_FULL')}{enterprise}-macos-X64"
+          mac_x64_pkg = f"UltiMaker-Cura-{os.getenv('CURA_VERSION_FULL')}{enterprise}-macos-X64"
+          mac_arm_dmg = f"UltiMaker-Cura-{os.getenv('CURA_VERSION_FULL')}{enterprise}-macos-ARM64"
+          mac_arm_pkg = f"UltiMaker-Cura-{os.getenv('CURA_VERSION_FULL')}{enterprise}-macos-ARM64"
+          win_msi = installer_filename = f"UltiMaker-Cura-{os.getenv('CURA_VERSION_FULL')}{enterprise}-win64-X64"
+          win_exe = installer_filename = f"UltiMaker-Cura-{os.getenv('CURA_VERSION_FULL')}{enterprise}-win64-X64"
+          nightly_name = "UltiMaker-Cura-" + os.getenv('CURA_VERSION_FULL').split("+")[0]
+          nightly_creation_time = str(datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
+          output_env = os.environ["GITHUB_OUTPUT"]
+          content = ""
+          if os.path.exists(output_env):
+              with open(output_env, "r") as f:
+                  content = f.read()
+          with open(output_env, "w") as f:
+              f.write(content)
+              f.writelines(f"LINUX={linux}\n")
+              f.writelines(f"MAC_X64_DMG={mac_x64_dmg}\n")
+              f.writelines(f"MAC_X64_PKG={mac_x64_pkg}\n")
+              f.writelines(f"MAC_ARM_DMG={mac_arm_dmg}\n")
+              f.writelines(f"MAC_ARM_PKG={mac_arm_pkg}\n")
+              f.writelines(f"WIN_MSI={win_msi}\n")
+              f.writelines(f"WIN_EXE={win_exe}\n")
+              f.writelines(f"NIGHTLY_NAME={nightly_name}\n")
+              f.writelines(f"NIGHTLY_TIME={nightly_creation_time}\n")
+
+      - name: Download linux installer jobs artifacts
+        uses: actions/download-artifact@v2
+        with:
+          name: ${{ steps.filename.outputs.LINUX }}-AppImage
+          path: installers
+          
+      - name: Download linux installer jobs asc artifacts
+        uses: actions/download-artifact@v2
+        with:
+          name: ${{ steps.filename.outputs.LINUX }}-asc
+          path: installers
+
+      - name: Rename Linux installer to nightlies
+        run: |
+          mv installers/${{ steps.filename.outputs.LINUX }}.AppImage installers/${{ steps.filename.outputs.NIGHTLY_NAME }}-linux-X64.AppImage
+          mv installers/${{ steps.filename.outputs.LINUX }}.AppImage.asc installers/${{ steps.filename.outputs.NIGHTLY_NAME }}-linux-X64.AppImage.asc
+
+      - name: Update nightly release for Linux
+        run: |
+          gh release upload nightly installers/${{ steps.filename.outputs.NIGHTLY_NAME }}-linux-X64.AppImage --clobber
+          gh release upload nightly installers/${{ steps.filename.outputs.NIGHTLY_NAME }}-linux-X64.AppImage.asc  --clobber
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Download win msi installer jobs artifacts
+        uses: actions/download-artifact@v2
+        with:
+          name: ${{ steps.filename.outputs.WIN_MSI }}-msi
+          path: installers
+
+      - name: Download win exe installer jobs artifacts
+        uses: actions/download-artifact@v2
+        with:
+          name: ${{ steps.filename.outputs.WIN_EXE }}-exe
+          path: installers
+
+      - name: Rename Windows installers to nightlies
+        run: |
+          mv installers/${{ steps.filename.outputs.WIN_MSI }}.msi installers/${{ steps.filename.outputs.NIGHTLY_NAME }}-win64-X64.msi
+          mv installers/${{ steps.filename.outputs.WIN_EXE }}.exe installers/${{ steps.filename.outputs.NIGHTLY_NAME }}-win64-X64.exe
+
+      - name: Update nightly release for Windows
+        run: |
+          gh release upload nightly installers/${{ steps.filename.outputs.NIGHTLY_NAME }}-win64-X64.msi --clobber
+          gh release upload nightly installers/${{ steps.filename.outputs.NIGHTLY_NAME }}-win64-X64.exe --clobber
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Download MacOS (X64) dmg installer jobs artifacts
+        uses: actions/download-artifact@v2
+        with:
+          name: ${{ steps.filename.outputs.MAC_X64_DMG }}-dmg
+          path: installers
+
+      - name: Download MacOS (X64) pkg installer jobs artifacts
+        uses: actions/download-artifact@v2
+        with:
+          name: ${{ steps.filename.outputs.MAC_X64_PKG }}-pkg
+          path: installers
+
+      - name: Rename MacOS (X64) installers to nightlies
+        run: |
+          mv installers/${{ steps.filename.outputs.MAC_X64_DMG }}.dmg installers/${{ steps.filename.outputs.NIGHTLY_NAME }}-macos-X64.dmg
+          mv installers/${{ steps.filename.outputs.MAC_X64_PKG }}.pkg installers/${{ steps.filename.outputs.NIGHTLY_NAME }}-macos-X64.pkg
+
+      - name: Update nightly release for MacOS (X64)
+        run: |
+          gh release upload nightly installers/${{ steps.filename.outputs.NIGHTLY_NAME }}-macos-X64.dmg --clobber
+          gh release upload nightly installers/${{ steps.filename.outputs.NIGHTLY_NAME }}-macos-X64.pkg --clobber
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Download MacOS (ARM-64) dmg installer jobs artifacts
+        uses: actions/download-artifact@v2
+        with:
+          name: ${{ steps.filename.outputs.MAC_ARM_DMG }}-dmg
+          path: installers
+
+      - name: Download MacOS (ARM-64) pkg installer jobs artifacts
+        uses: actions/download-artifact@v2
+        with:
+          name: ${{ steps.filename.outputs.MAC_ARM_PKG }}-pkg
+          path: installers
+
+      - name: Rename MacOS (ARM-64) installers to nightlies
+        run: |
+          mv installers/${{ steps.filename.outputs.MAC_ARM_DMG }}.dmg installers/${{ steps.filename.outputs.NIGHTLY_NAME }}-macos-ARM64.dmg
+          mv installers/${{ steps.filename.outputs.MAC_ARM_PKG }}.pkg installers/${{ steps.filename.outputs.NIGHTLY_NAME }}-macos-ARM64.pkg
+
+      - name: Update nightly release for MacOS (ARM-64)
+        run: |
+          gh release upload nightly installers/${{ steps.filename.outputs.NIGHTLY_NAME }}-macos-ARM64.dmg --clobber
+          gh release upload nightly installers/${{ steps.filename.outputs.NIGHTLY_NAME }}-macos-ARM64.pkg --clobber
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Update nightly release description (with date)
+        if: always()
+        run: |
+          gh release edit nightly --title "${{ steps.filename.outputs.NIGHTLY_NAME }}" --notes "Nightly release created on: ${{ steps.filename.outputs.NIGHTLY_TIME }}"
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/linux.yml

@@ -0,0 +1,293 @@
+name: Linux Installer
+run-name: ${{ inputs.cura_conan_version }} for Linux-${{ inputs.architecture }} by @${{ github.actor }}
+
+on:
+  workflow_dispatch:
+    inputs:
+      cura_conan_version:
+        description: 'Cura Conan Version'
+        default: 'cura/latest@ultimaker/testing'
+        required: true
+        type: string
+      conan_args:
+        description: 'Conan args: eq.: --require-override'
+        default: ''
+        required: false
+        type: string
+      enterprise:
+        description: 'Build Cura as an Enterprise edition'
+        default: false
+        required: true
+        type: boolean
+      staging:
+        description: 'Use staging API'
+        default: false
+        required: true
+        type: boolean
+      architecture:
+        description: 'Architecture'
+        required: true
+        default: 'X64'
+        type: choice
+        options:
+          - X64
+      operating_system:
+        description: 'OS'
+        required: true
+        default: 'ubuntu-22.04'
+        type: choice
+        options:
+          - ubuntu-22.04
+
+  workflow_call:
+    inputs:
+      cura_conan_version:
+        description: 'Cura Conan Version'
+        default: 'cura/latest@ultimaker/testing'
+        required: true
+        type: string
+      conan_args:
+        description: 'Conan args: eq.: --require-override'
+        default: ''
+        required: false
+        type: string
+      enterprise:
+        description: 'Build Cura as an Enterprise edition'
+        default: false
+        required: true
+        type: boolean
+      staging:
+        description: 'Use staging API'
+        default: false
+        required: true
+        type: boolean
+      architecture:
+        description: 'Architecture'
+        required: true
+        default: 'X64'
+        type: string
+      operating_system:
+        description: 'OS'
+        required: true
+        default: 'ubuntu-22.04'
+        type: string
+
+env:
+  CONAN_LOGIN_USERNAME_CURA: ${{ secrets.CONAN_USER }}
+  CONAN_PASSWORD_CURA: ${{ secrets.CONAN_PASS }}
+  GPG_PRIVATE_KEY: ${{ secrets.GPG_PRIVATE_KEY }}
+  CURA_CONAN_VERSION: ${{ inputs.cura_conan_version }}
+  ENTERPRISE: ${{ inputs.enterprise }}
+  STAGING: ${{ inputs.staging }}
+
+jobs:
+  cura-installer-create:
+    runs-on: ${{ inputs.operating_system }}
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+
+      - name: Setup Python and pip
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.10.x'
+          cache: 'pip'
+          cache-dependency-path: .github/workflows/requirements-conan-package.txt
+
+      - name: Install Python requirements for runner
+        run: pip install -r .github/workflows/requirements-conan-package.txt
+
+      - name: Cache Conan local repository packages (Bash)
+        uses: actions/cache@v3
+        with:
+          path: |
+            $HOME/.conan/data
+            $HOME/.conan/conan_download_cache
+          key: conan-${{ runner.os }}-${{ runner.arch }}-installer-cache
+
+      - name: Hack needed specifically for ubuntu-22.04 from mid-Feb 2023 onwards
+        if: ${{ startsWith(inputs.operating_system, 'ubuntu-22.04') }}
+        run: sudo apt remove libodbc2 libodbcinst2 unixodbc-common -y
+
+      # NOTE: Due to what are probably github issues, we have to remove the cache and reconfigure before the rest.
+      #       This is maybe because grub caches the disk it uses last time, which is recreated each time.
+      - name: Install Linux system requirements
+        run: |
+          sudo rm /var/cache/debconf/config.dat
+          sudo dpkg --configure -a
+          sudo add-apt-repository ppa:ubuntu-toolchain-r/test -y
+          sudo apt update
+          sudo apt upgrade
+          sudo apt install build-essential checkinstall libegl-dev zlib1g-dev libssl-dev ninja-build autoconf libx11-dev libx11-xcb-dev libfontenc-dev libice-dev libsm-dev libxau-dev libxaw7-dev libxcomposite-dev libxcursor-dev libxdamage-dev libxdmcp-dev libxext-dev libxfixes-dev libxi-dev libxinerama-dev libxkbfile-dev libxmu-dev libxmuu-dev libxpm-dev libxrandr-dev libxrender-dev libxres-dev libxss-dev libxt-dev libxtst-dev libxv-dev libxvmc-dev libxxf86vm-dev xtrans-dev libxcb-render0-dev libxcb-render-util0-dev libxcb-xkb-dev libxcb-icccm4-dev libxcb-image0-dev libxcb-keysyms1-dev libxcb-randr0-dev libxcb-shape0-dev libxcb-sync-dev libxcb-xfixes0-dev libxcb-xinerama0-dev xkb-data libxcb-dri3-dev uuid-dev libxcb-util-dev libxkbcommon-x11-dev pkg-config binutils coreutils desktop-file-utils fakeroot fuse libgdk-pixbuf2.0-dev patchelf squashfs-tools strace util-linux zsync -y
+          
+          # Get the AppImage tool
+          wget --no-check-certificate --quiet https://github.com/AppImage/AppImageKit/releases/download/continuous/appimagetool-x86_64.AppImage -O $GITHUB_WORKSPACE/appimagetool
+          chmod +x $GITHUB_WORKSPACE/appimagetool
+          echo "APPIMAGETOOL_LOCATION=$GITHUB_WORKSPACE/appimagetool" >> $GITHUB_ENV
+          
+          # Get the AppImage builder
+          wget --no-check-certificate --quiet -O $GITHUB_WORKSPACE/appimage-builder-x86_64.AppImage https://github.com/AppImageCrafters/appimage-builder/releases/download/v1.1.0/appimage-builder-1.1.0-x86_64.AppImage
+          chmod +x appimage-builder-x86_64.AppImage
+          echo "APPIMAGEBUILDER_LOCATION=$GITHUB_WORKSPACE/appimage-builder-x86_64.AppImage" >> $GITHUB_ENV
+          
+          # Make sure these tools can be found on the path
+          echo "$GITHUB_WORKSPACE" >> $GITHUB_PATH          
+
+      - name: Install GCC-13
+        run: |
+          sudo apt install g++-13 gcc-13 -y
+          sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-13 13
+          sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-13 13
+
+      - name: Create the default Conan profile
+        run: conan profile new default --detect --force
+
+      - name: Configure GPG Key Linux (Bash)
+        run: echo -n "$GPG_PRIVATE_KEY" | base64 --decode | gpg --import
+
+      - name: Get Conan configuration
+        run: |
+          conan config install https://github.com/Ultimaker/conan-config.git
+          conan config install https://github.com/Ultimaker/conan-config.git -a "-b runner/${{ runner.os }}/${{ runner.arch }}"
+
+      - name: Use Conan download cache (Bash)
+        run: conan config set storage.download_cache="$HOME/.conan/conan_download_cache"
+
+      - name: Create the Packages (Bash)
+        run: conan install $CURA_CONAN_VERSION ${{ inputs.conan_args }} --build=missing --update -if cura_inst -g VirtualPythonEnv -o cura:enterprise=$ENTERPRISE -o cura:staging=$STAGING --json "cura_inst/conan_install_info.json"
+
+      - name: Upload the Package(s)
+        if: always()
+        run: |
+          conan upload "*" -r cura --all -c
+
+      - name: Set Environment variables for Cura (bash)
+        run: |
+          . ./cura_inst/bin/activate_github_actions_env.sh
+          . ./cura_inst/bin/activate_github_actions_version_env.sh
+
+        # FIXME: This is a workaround to ensure that we use and pack a shared library for OpenSSL 1.1.1l. We currently compile
+        #  OpenSSL statically for CPython, but our Python Dependenies (such as PyQt6) require a shared library.
+        #  Because Conan won't allow for building the same library with two different options (easily) we need to install it explicitly
+        #  and do a manual copy to the VirtualEnv, such that Pyinstaller can find it.
+
+      - name: Install OpenSSL shared
+        run: conan install openssl/1.1.1l@_/_ --build=missing --update -o openssl:shared=True -g deploy
+
+      - name: Copy OpenSSL shared (Bash)
+        run: |
+          cp ./openssl/lib/*.so* ./cura_inst/bin/ || true
+          cp ./openssl/lib/*.dylib* ./cura_inst/bin/ || true                    
+
+      - name: Create the Cura dist
+        run: pyinstaller ./cura_inst/UltiMaker-Cura.spec
+
+      - name: Output the name file name and extension
+        id: filename
+        shell: python
+        run: |
+          import os
+          enterprise = "-Enterprise" if "${{ inputs.enterprise }}" == "true" else ""
+          installer_filename = f"UltiMaker-Cura-{os.getenv('CURA_VERSION_FULL')}{enterprise}-linux-${{ inputs.architecture }}"
+          output_env = os.environ["GITHUB_OUTPUT"]
+          content = ""
+          if os.path.exists(output_env):
+              with open(output_env, "r") as f:
+                  content = f.read()
+          with open(output_env, "w") as f:
+              f.write(content)
+              f.writelines(f"INSTALLER_FILENAME={installer_filename}\n")
+
+      - name: Summarize the used Conan dependencies
+        shell: python
+        run: |
+          import os
+          import json
+          from pathlib import Path
+          
+          conan_install_info_path = Path("cura_inst/conan_install_info.json")
+          conan_info = {"installed": []}
+          if os.path.exists(conan_install_info_path):
+              with open(conan_install_info_path, "r") as f:
+                  conan_info = json.load(f)
+          sorted_deps = sorted([dep["recipe"]["id"].replace('#', r' rev: ') for dep in conan_info["installed"]])
+          
+          summary_env = os.environ["GITHUB_STEP_SUMMARY"]
+          content = ""
+          if os.path.exists(summary_env):
+              with open(summary_env, "r") as f:
+                  content = f.read()
+          
+          with open(summary_env, "w") as f:
+              f.write(content)
+              f.writelines("# ${{ steps.filename.outputs.INSTALLER_FILENAME }}\n")
+              f.writelines("## Conan packages:\n")
+              for dep in sorted_deps:
+                  f.writelines(f"`{dep}`\n")
+
+      - name: Summarize the used Python modules
+        shell: python
+        run: |
+          import os
+          import pkg_resources
+          summary_env = os.environ["GITHUB_STEP_SUMMARY"]
+          content = ""
+          if os.path.exists(summary_env):
+              with open(summary_env, "r") as f:
+                  content = f.read()
+          
+          with open(summary_env, "w") as f:
+              f.write(content)
+              f.writelines("## Python modules:\n")
+              for package in pkg_resources.working_set:
+                  f.writelines(f"`{package.key}/{package.version}`\n")
+
+      - name: Create the Linux AppImage (Bash)
+        run: |
+          python ../cura_inst/packaging/AppImage-builder/create_appimage.py ./UltiMaker-Cura $CURA_VERSION_FULL "${{ steps.filename.outputs.INSTALLER_FILENAME }}.AppImage"
+          chmod +x "${{ steps.filename.outputs.INSTALLER_FILENAME }}.AppImage"
+        working-directory: dist
+
+      - name: Upload the AppImage
+        uses: actions/upload-artifact@v3
+        with:
+          name: ${{ steps.filename.outputs.INSTALLER_FILENAME }}-AppImage
+          path: |
+            dist/${{ steps.filename.outputs.INSTALLER_FILENAME }}.AppImage
+          retention-days: 5
+
+      - name: Upload the asc
+        uses: actions/upload-artifact@v3
+        with:
+          name: ${{ steps.filename.outputs.INSTALLER_FILENAME }}-asc
+          path: |
+            dist/${{ steps.filename.outputs.INSTALLER_FILENAME }}.AppImage.asc
+          retention-days: 5
+
+      - name: Write the run info
+        shell: python
+        run: |
+          import os
+          with open("run_info.sh", "w") as f:
+              f.writelines(f'echo "CURA_VERSION_FULL={os.environ["CURA_VERSION_FULL"]}" >> $GITHUB_ENV\n')
+      - name: Upload the run info
+        uses: actions/upload-artifact@v3
+        with:
+          name: linux-run-info
+          path: |
+            run_info.sh
+          retention-days: 5
+
+  notify-export:
+    if: ${{ always() }}
+    needs: [ cura-installer-create ]
+
+    uses: ultimaker/cura/.github/workflows/notify.yml@main
+    with:
+      success: ${{ contains(join(needs.*.result, ','), 'success') }}
+      success_title: "Create the Cura distributions"
+      success_body: "Installers for ${{ inputs.cura_conan_version }}"
+      failure_title: "Failed to create the Cura distributions"
+      failure_body: "Failed to create at least 1 installer for ${{ inputs.cura_conan_version }}"
+    secrets: inherit

.github/workflows/macos.yml

@@ -0,0 +1,294 @@
+name: Macos Installer
+run-name: ${{ inputs.cura_conan_version }} for Macos-${{ inputs.architecture }} by @${{ github.actor }}
+
+on:
+  workflow_dispatch:
+    inputs:
+      cura_conan_version:
+        description: 'Cura Conan Version'
+        default: 'cura/latest@ultimaker/testing'
+        required: true
+        type: string
+      conan_args:
+        description: 'Conan args: eq.: --require-override'
+        default: ''
+        required: false
+        type: string
+      enterprise:
+        description: 'Build Cura as an Enterprise edition'
+        default: false
+        required: true
+        type: boolean
+      staging:
+        description: 'Use staging API'
+        default: false
+        required: true
+        type: boolean
+      architecture:
+        description: 'Architecture'
+        required: true
+        default: 'X64'
+        type: choice
+        options:
+          - X64
+          - ARM64
+      operating_system:
+        description: 'OS'
+        required: true
+        default: 'macos-11'
+        type: choice
+        options:
+          - self-hosted
+          - macos-11
+          - macos-12
+  workflow_call:
+    inputs:
+      cura_conan_version:
+        description: 'Cura Conan Version'
+        default: 'cura/latest@ultimaker/testing'
+        required: true
+        type: string
+      conan_args:
+        description: 'Conan args: eq.: --require-override'
+        default: ''
+        required: false
+        type: string
+      enterprise:
+        description: 'Build Cura as an Enterprise edition'
+        default: false
+        required: true
+        type: boolean
+      staging:
+        description: 'Use staging API'
+        default: false
+        required: true
+        type: boolean
+      architecture:
+        description: 'Architecture'
+        required: true
+        default: 'X64'
+        type: string
+      operating_system:
+        description: 'OS'
+        required: true
+        default: 'macos-11'
+        type: string
+
+env:
+  CONAN_LOGIN_USERNAME_CURA: ${{ secrets.CONAN_USER }}
+  CONAN_PASSWORD_CURA: ${{ secrets.CONAN_PASS }}
+  CODESIGN_IDENTITY: ${{ secrets.CODESIGN_IDENTITY }}
+  MAC_NOTARIZE_USER: ${{ secrets.MAC_NOTARIZE_USER }}
+  MAC_NOTARIZE_PASS: ${{ secrets.MAC_NOTARIZE_PASS }}
+  MACOS_CERT_P12: ${{ secrets.MACOS_CERT_P12 }}
+  MACOS_CERT_INSTALLER_P12: ${{ secrets.MACOS_CERT_INSTALLER_P12 }}
+  MACOS_CERT_USER: ${{ secrets.MACOS_CERT_USER }}
+  MACOS_CERT_PASSPHRASE: ${{ secrets.MACOS_CERT_PASSPHRASE }}
+  CURA_CONAN_VERSION: ${{ inputs.cura_conan_version }}
+  ENTERPRISE: ${{ inputs.enterprise }}
+  STAGING: ${{ inputs.staging }}
+
+jobs:
+  cura-installer-create:
+    runs-on: ${{ inputs.operating_system }}
+
+    outputs:
+      INSTALLER_FILENAME: ${{ steps.filename.outputs.INSTALLER_FILENAME }}
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+
+      - name: Setup Python and pip
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.10.x'
+          cache: 'pip'
+          cache-dependency-path: .github/workflows/requirements-conan-package.txt
+
+      - name: Install Python requirements for runner
+        run: pip install -r .github/workflows/requirements-conan-package.txt
+
+      - name: Cache Conan local repository packages (Bash)
+        uses: actions/cache@v3
+        with:
+          path: |
+            $HOME/.conan/data
+            $HOME/.conan/conan_download_cache
+          key: conan-${{ runner.os }}-${{ runner.arch }}-installer-cache
+
+      - name: Install MacOS system requirements
+        run: brew install cmake autoconf automake ninja create-dmg
+
+      - name: Create the default Conan profile
+        run: conan profile new default --detect --force
+
+      - name: Remove Macos keychain (Bash)
+        run: security delete-keychain signing_temp.keychain || true
+
+      - name: Configure Macos keychain Developer Cert(Bash)
+        id: macos-keychain-developer-cert
+        uses: apple-actions/import-codesign-certs@v1
+        with:
+          keychain-password: ${{ secrets.MACOS_KEYCHAIN_PASSWORD }}
+          p12-file-base64: ${{ secrets.MACOS_CERT_P12 }}
+          p12-password: ${{ secrets.MACOS_CERT_PASSPHRASE }}
+
+      - name: Configure Macos keychain Installer Cert (Bash)
+        id: macos-keychain-installer-cert
+        uses: apple-actions/import-codesign-certs@v1
+        with:
+          keychain-password: ${{ secrets.MACOS_KEYCHAIN_PASSWORD }}
+          create-keychain: false # keychain is created in previous use of action.
+          p12-file-base64: ${{ secrets.MACOS_CERT_INSTALLER_P12 }}
+          p12-password: ${{ secrets.MACOS_CERT_PASSPHRASE }}
+
+      - name: Get Conan configuration
+        run: |
+          conan config install https://github.com/Ultimaker/conan-config.git
+          conan config install https://github.com/Ultimaker/conan-config.git -a "-b runner/${{ runner.os }}/${{ runner.arch }}"
+
+      - name: Use Conan download cache (Bash)
+        run: conan config set storage.download_cache="$HOME/.conan/conan_download_cache"
+
+      - name: Create the Packages (Bash)
+        run: conan install $CURA_CONAN_VERSION ${{ inputs.conan_args }} --build=missing --update -if cura_inst -g VirtualPythonEnv -o cura:enterprise=$ENTERPRISE -o cura:staging=$STAGING --json "cura_inst/conan_install_info.json"
+
+      - name: Upload the Package(s)
+        if: always()
+        run: |
+          conan upload "*" -r cura --all -c
+
+      - name: Set Environment variables for Cura (bash)
+        run: |
+          . ./cura_inst/bin/activate_github_actions_env.sh
+          . ./cura_inst/bin/activate_github_actions_version_env.sh
+
+      - name: Unlock Macos keychain (Bash)
+        run: security unlock -p $TEMP_KEYCHAIN_PASSWORD signing_temp.keychain
+        env:
+          TEMP_KEYCHAIN_PASSWORD: ${{  steps.macos-keychain-developer-cert.outputs.keychain-password }}
+
+        # FIXME: This is a workaround to ensure that we use and pack a shared library for OpenSSL 1.1.1l. We currently compile
+        #  OpenSSL statically for CPython, but our Python Dependenies (such as PyQt6) require a shared library.
+        #  Because Conan won't allow for building the same library with two different options (easily) we need to install it explicitly
+        #  and do a manual copy to the VirtualEnv, such that Pyinstaller can find it.
+      - name: Install OpenSSL shared
+        run: conan install openssl/1.1.1l@_/_ --build=missing --update -o openssl:shared=True -g deploy
+
+      - name: Copy OpenSSL shared (Bash)
+        run: |
+          cp ./openssl/lib/*.so* ./cura_inst/bin/ || true
+          cp ./openssl/lib/*.dylib* ./cura_inst/bin/ || true                    
+
+      - name: Create the Cura dist
+        run: pyinstaller ./cura_inst/UltiMaker-Cura.spec
+
+      - name: Output the name file name and extension
+        id: filename
+        shell: python
+        run: |
+          import os
+          enterprise = "-Enterprise" if "${{ inputs.enterprise }}" == "true" else ""
+          installer_filename = f"UltiMaker-Cura-{os.getenv('CURA_VERSION_FULL')}{enterprise}-macos-${{ inputs.architecture }}"
+          output_env = os.environ["GITHUB_OUTPUT"]
+          content = ""
+          if os.path.exists(output_env):
+              with open(output_env, "r") as f:
+                  content = f.read()
+          with open(output_env, "w") as f:
+              f.write(content)
+              f.writelines(f"INSTALLER_FILENAME={installer_filename}\n")
+
+      - name: Summarize the used Conan dependencies
+        shell: python
+        run: |
+          import os
+          import json
+          from pathlib import Path
+          
+          conan_install_info_path = Path("cura_inst/conan_install_info.json")
+          conan_info = {"installed": []}
+          if os.path.exists(conan_install_info_path):
+              with open(conan_install_info_path, "r") as f:
+                  conan_info = json.load(f)
+          sorted_deps = sorted([dep["recipe"]["id"].replace('#', r' rev: ') for dep in conan_info["installed"]])
+          
+          summary_env = os.environ["GITHUB_STEP_SUMMARY"]
+          content = ""
+          if os.path.exists(summary_env):
+              with open(summary_env, "r") as f:
+                  content = f.read()
+          
+          with open(summary_env, "w") as f:
+              f.write(content)
+              f.writelines("# ${{ steps.filename.outputs.INSTALLER_FILENAME }}\n")
+              f.writelines("## Conan packages:\n")
+              for dep in sorted_deps:
+                  f.writelines(f"`{dep}`\n")
+
+      - name: Summarize the used Python modules
+        shell: python
+        run: |
+          import os
+          import pkg_resources
+          summary_env = os.environ["GITHUB_STEP_SUMMARY"]
+          content = ""
+          if os.path.exists(summary_env):
+              with open(summary_env, "r") as f:
+                  content = f.read()
+          
+          with open(summary_env, "w") as f:
+              f.write(content)
+              f.writelines("## Python modules:\n")
+              for package in pkg_resources.working_set:
+                  f.writelines(f"`{package.key}/{package.version}`\n")
+
+      - name: Create the Macos dmg (Bash)
+        run: python ../cura_inst/packaging/MacOS/build_macos.py --source_path ../cura_inst --dist_path . --cura_conan_version $CURA_CONAN_VERSION --filename "${{ steps.filename.outputs.INSTALLER_FILENAME }}" --build_dmg --build_pkg --app_name "$CURA_APP_NAME"
+        working-directory: dist
+
+      - name: Upload the dmg
+        uses: actions/upload-artifact@v3
+        with:
+          name: ${{ steps.filename.outputs.INSTALLER_FILENAME }}-dmg
+          path: |
+            dist/${{ steps.filename.outputs.INSTALLER_FILENAME }}.dmg
+          retention-days: 5
+
+      - name: Upload the pkg
+        uses: actions/upload-artifact@v3
+        with:
+          name: ${{ steps.filename.outputs.INSTALLER_FILENAME }}-pkg
+          path: |
+            dist/${{ steps.filename.outputs.INSTALLER_FILENAME }}.pkg
+          retention-days: 5
+
+      - name: Write the run info
+        shell: python
+        run: |
+          import os
+          with open("run_info.sh", "w") as f:
+              f.writelines(f'echo "CURA_VERSION_FULL={os.environ["CURA_VERSION_FULL"]}" >> $GITHUB_ENV\n')
+
+      - name: Upload the run info
+        uses: actions/upload-artifact@v3
+        with:
+          name: macos-run-info
+          path: |
+            run_info.sh
+          retention-days: 5
+
+
+  notify-export:
+    if: ${{ always() }}
+    needs: [ cura-installer-create ]
+
+    uses: ultimaker/cura/.github/workflows/notify.yml@main
+    with:
+      success: ${{ contains(join(needs.*.result, ','), 'success') }}
+      success_title: "Create the Cura distributions"
+      success_body: "Installers for ${{ inputs.cura_conan_version }}"
+      failure_title: "Failed to create the Cura distributions"
+      failure_body: "Failed to create at least 1 installer for ${{ inputs.cura_conan_version }}"
+    secrets: inherit

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

@@ -18,19 +18,20 @@ jobs:
             -   name: Checkout
                 uses: actions/checkout@v3
 
-            -   name: Setup Python and pip
-                uses: actions/setup-python@v4
-                with:
-                    python-version: 3.11.x
-                    cache: 'pip'
-                    cache-dependency-path: .github/workflows/requirements-printer-linter.txt
-
             -   uses: technote-space/get-diff-action@v6
                 with:
                     PATTERNS: |
                         resources/+(definitions|extruders)/*.def.json
                         resources/+(intent|quality|variants)/**/*.inst.cfg
 
+            -   name: Setup Python and pip
+                if: env.GIT_DIFF && !env.MATCHED_FILES  # If nothing happens with python and/or pip after, the clean-up crashes.
+                uses: actions/setup-python@v4
+                with:
+                    python-version: 3.11.x
+                    cache: 'pip'
+                    cache-dependency-path: .github/workflows/requirements-printer-linter.txt
+
             -   name: Install Python requirements for runner
                 if: env.GIT_DIFF && !env.MATCHED_FILES
                 run: pip install -r .github/workflows/requirements-printer-linter.txt

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

@@ -16,19 +16,20 @@ jobs:
         with:
           fetch-depth: 2
 
-      - name: Setup Python and pip
-        uses: actions/setup-python@v4
-        with:
-          python-version: 3.11.x
-          cache: "pip"
-          cache-dependency-path: .github/workflows/requirements-printer-linter.txt
-
       - uses: technote-space/get-diff-action@v6
         with:
           PATTERNS: |
             resources/+(extruders|definitions)/*.def.json
             resources/+(intent|quality|variants)/**/*.inst.cfg
 
+      - name: Setup Python and pip
+        if: env.GIT_DIFF && !env.MATCHED_FILES  # If nothing happens with python and/or pip after, the clean-up crashes.
+        uses: actions/setup-python@v4
+        with:
+          python-version: 3.11.x
+          cache: "pip"
+          cache-dependency-path: .github/workflows/requirements-printer-linter.txt
+
       - name: Install Python requirements for runner
         if: env.GIT_DIFF && !env.MATCHED_FILES
         run: pip install -r .github/workflows/requirements-printer-linter.txt

.github/workflows/requirements-conan-package.txt

@@ -1,2 +1,2 @@
-conan!=1.51.0,!=1.51.1,!=1.51.2,!=1.51.3,!=1.52.0,!=1.57.0,!=1.58.0
+conan>=1.60.2,<2.0.0
 sip

.github/workflows/security_badge.yml

@@ -0,0 +1,71 @@
+# NOTE: Best to keep all of these remarks in, they might prove useful in the future.
+#       This is basically just the standard one that is sugested on 'new workflow'.
+
+name: Scorecard supply-chain security
+on:
+  # For Branch-Protection check. Only the default branch is supported. See
+  # https://github.com/ossf/scorecard/blob/main/docs/checks.md#branch-protection
+  branch_protection_rule:
+  # To guarantee Maintained check is occasionally updated. See
+  # https://github.com/ossf/scorecard/blob/main/docs/checks.md#maintained
+  schedule:
+    - cron: '25 2 * * 5'
+  push:
+    branches: [ "main" ]
+
+# Declare default permissions as read only.
+permissions: read-all
+
+jobs:
+  analysis:
+    name: Scorecard analysis
+    runs-on: ubuntu-latest
+    permissions:
+      # Needed to upload the results to code-scanning dashboard.
+      security-events: write
+      # Needed to publish results and get a badge (see publish_results below).
+      id-token: write
+      # Uncomment the permissions below if installing in a private repository.
+      # contents: read
+      # actions: read
+
+    steps:
+      - name: "Checkout code"
+        uses: actions/checkout@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8 # v3.1.0
+        with:
+          persist-credentials: false
+
+      - name: "Run analysis"
+        uses: ossf/scorecard-action@e38b1902ae4f44df626f11ba0734b14fb91f8f86 # v2.1.2
+        with:
+          results_file: results.sarif
+          results_format: sarif
+          # (Optional) "write" PAT token. Uncomment the `repo_token` line below if:
+          # - you want to enable the Branch-Protection check on a *public* repository, or
+          # - you are installing Scorecard on a *private* repository
+          # To create the PAT, follow the steps in https://github.com/ossf/scorecard-action#authentication-with-pat.
+          # repo_token: ${{ secrets.SCORECARD_TOKEN }}
+
+          # Public repositories:
+          #   - Publish results to OpenSSF REST API for easy access by consumers
+          #   - Allows the repository to include the Scorecard badge.
+          #   - See https://github.com/ossf/scorecard-action#publishing-results.
+          # For private repositories:
+          #   - `publish_results` will always be set to `false`, regardless
+          #     of the value entered here.
+          publish_results: true
+
+      # Upload the results as artifacts (optional). Commenting out will disable uploads of run results in SARIF
+      # format to the repository Actions tab.
+      - name: "Upload artifact"
+        uses: actions/upload-artifact@3cea5372237819ed00197afe530f5a7ea3e805c8 # v3.1.0
+        with:
+          name: SARIF file
+          path: results.sarif
+          retention-days: 5
+
+      # Upload the results to GitHub's code scanning dashboard.
+      - name: "Upload to code-scanning"
+        uses: github/codeql-action/upload-sarif@17573ee1cc1b9d061760f3a006fc4aac4f944fd5 # v2.2.4
+        with:
+          sarif_file: results.sarif

.github/workflows/stale.yml

@@ -0,0 +1,37 @@
+name: 'Close stale issues and PRs'
+on:
+  schedule:
+    - cron: '0 9-17/4 * * *'
+    
+jobs:
+  stale:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/stale@v8
+        with:
+          days-before-pr-close: -1 
+          days-before-stale: 365
+          days-before-close: 14
+          operations-per-run: 3000
+          ascending: true
+          exempt-issue-labels: 'Status: Triage,Developer Environment :computer:,Status: On Backlog,PR: Community Contribution :crown:,PR: Printer Definitions :factory:,PR: Translations :books:'
+          stale-issue-label: 'Status: Stale :hourglass:'
+          labels-to-add-when-unstale: 'Status: Triage'
+          only-labels: "Type: New Feature,Status: Deferred"
+          stale-issue-message: |
+           Hi 👋, 
+           We are cleaning our list of issues to improve our focus. 
+           This feature request seems to be older than a year, which is at least three major Cura releases ago. 
+           It also received the label Deferred indicating that we did not have time to work on it back then and haven't found time to work on it since. 
+           
+           If this is still something that you think can improve how you and others use Cura, can you please leave a comment? 
+           We will have a fresh set of eyes to look at it. 
+
+           If it has been resolved or don't need it to be improved anymore, you don't have to do anything, and this issue will be automatically closed in 14 days.
+          close-issue-message: |
+           This issue was closed because it has been inactive for 14 days since being marked as stale. 
+           If you encounter this issue and still have a need for this, you are welcome to make a fresh new issue with an updated description.
+permissions:
+  contents: write # only for delete-branch option
+  issues: write
+  pull-requests: write

.github/workflows/unit-test-post.yml

@@ -79,4 +79,4 @@ jobs:
                     files: "tests/**/*.xml"
 
             -   name: Conclusion
-                run: echo "Conclusion is ${{ fromJSON( steps.test-results.outputs.json ).conclusion }}"
+                run: echo "Conclusion is ${{ steps.test-results.outputs.json && fromJSON( steps.test-results.outputs.json ).conclusion }}"

.github/workflows/unit-test.yml

@@ -2,156 +2,165 @@
 name: unit-test
 
 on:
-    push:
-        paths:
-            - 'plugins/**'
-            - 'resources/**'
-            - 'cura/**'
-            - 'icons/**'
-            - 'tests/**'
-            - 'packaging/**'
-            - '.github/workflows/conan-*.yml'
-            - '.github/workflows/unit-test.yml'
-            - '.github/workflows/notify.yml'
-            - '.github/workflows/requirements-conan-package.txt'
-            - 'requirements*.txt'
-            - 'conanfile.py'
-            - 'conandata.yml'
-            - 'GitVersion.yml'
-            - '*.jinja'
-        branches:
-            - main
-            - 'CURA-*'
-            - '[1-9]+.[0-9]+'
-        tags:
-            - '[0-9]+.[0-9]+.[0-9]+'
-            - '[0-9]+.[0-9]+-beta'
-    pull_request:
-        paths:
-            - 'plugins/**'
-            - 'resources/**'
-            - 'cura/**'
-            - 'icons/**'
-            - 'tests/**'
-            - 'packaging/**'
-            - '.github/workflows/conan-*.yml'
-            - '.github/workflows/unit-test.yml'
-            - '.github/workflows/notify.yml'
-            - '.github/workflows/requirements-conan-package.txt'
-            - 'requirements*.txt'
-            - 'conanfile.py'
-            - 'conandata.yml'
-            - 'GitVersion.yml'
-            - '*.jinja'
-        branches:
-            - main
-            - '[1-9]+.[0-9]+'
-        tags:
-            - '[0-9]+.[0-9]+.[0-9]+'
-            - '[0-9]+.[0-9]+-beta'
+  push:
+    paths:
+      - 'plugins/**'
+      - 'resources/**'
+      - 'cura/**'
+      - 'icons/**'
+      - 'tests/**'
+      - 'packaging/**'
+      - '.github/workflows/conan-*.yml'
+      - '.github/workflows/unit-test.yml'
+      - '.github/workflows/notify.yml'
+      - '.github/workflows/requirements-conan-package.txt'
+      - 'requirements*.txt'
+      - 'conanfile.py'
+      - 'conandata.yml'
+      - 'GitVersion.yml'
+      - '*.jinja'
+    branches:
+      - main
+      - 'CURA-*'
+      - '[1-9]+.[0-9]+'
+    tags:
+      - '[0-9]+.[0-9]+.[0-9]+'
+      - '[0-9]+.[0-9]+-beta'
+  pull_request:
+    paths:
+      - 'plugins/**'
+      - 'resources/**'
+      - 'cura/**'
+      - 'icons/**'
+      - 'tests/**'
+      - 'packaging/**'
+      - '.github/workflows/conan-*.yml'
+      - '.github/workflows/unit-test.yml'
+      - '.github/workflows/notify.yml'
+      - '.github/workflows/requirements-conan-package.txt'
+      - 'requirements*.txt'
+      - 'conanfile.py'
+      - 'conandata.yml'
+      - 'GitVersion.yml'
+      - '*.jinja'
+    branches:
+      - main
+      - '[1-9]+.[0-9]+'
+    tags:
+      - '[0-9]+.[0-9]+.[0-9]+'
+      - '[0-9]+.[0-9]+-beta'
 
 env:
-    CONAN_LOGIN_USERNAME_CURA: ${{ secrets.CONAN_USER }}
-    CONAN_PASSWORD_CURA: ${{ secrets.CONAN_PASS }}
-    CONAN_LOGIN_USERNAME_CURA_CE: ${{ secrets.CONAN_USER }}
-    CONAN_PASSWORD_CURA_CE: ${{ secrets.CONAN_PASS }}
-    CONAN_LOG_RUN_TO_OUTPUT: 1
-    CONAN_LOGGING_LEVEL: info
-    CONAN_NON_INTERACTIVE: 1
+  CONAN_LOGIN_USERNAME_CURA: ${{ secrets.CONAN_USER }}
+  CONAN_PASSWORD_CURA: ${{ secrets.CONAN_PASS }}
+  CONAN_LOGIN_USERNAME_CURA_CE: ${{ secrets.CONAN_USER }}
+  CONAN_PASSWORD_CURA_CE: ${{ secrets.CONAN_PASS }}
+  CONAN_LOG_RUN_TO_OUTPUT: 1
+  CONAN_LOGGING_LEVEL: info
+  CONAN_NON_INTERACTIVE: 1
 
 permissions:
   contents: read
 
 jobs:
-    conan-recipe-version:
-        uses: ultimaker/cura/.github/workflows/conan-recipe-version.yml@main
+  conan-recipe-version:
+    uses: ultimaker/cura/.github/workflows/conan-recipe-version.yml@main
+    with:
+      project_name: cura
+
+  testing:
+    runs-on: ubuntu-22.04
+    needs: [ conan-recipe-version ]
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
         with:
-            project_name: cura
+          fetch-depth: 2
 
-    testing:
-        runs-on: ubuntu-20.04
-        needs: [ conan-recipe-version ]
+      - name: Setup Python and pip
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.11.x'
+          architecture: 'x64'
+          cache: 'pip'
+          cache-dependency-path: .github/workflows/requirements-conan-package.txt
 
-        steps:
-            -   name: Checkout
-                uses: actions/checkout@v3
-                with:
-                    fetch-depth: 2
+      - name: Install Python requirements and Create default Conan profile
+        run: pip install -r requirements-conan-package.txt
+        working-directory: .github/workflows/
 
-            -   name: Setup Python and pip
-                uses: actions/setup-python@v4
-                with:
-                    python-version: '3.10.x'
-                    architecture: 'x64'
-                    cache: 'pip'
-                    cache-dependency-path: .github/workflows/requirements-conan-package.txt
+      - name: Use Conan download cache (Bash)
+        if: ${{ runner.os != 'Windows' }}
+        run: conan config set storage.download_cache="$HOME/.conan/conan_download_cache"
 
-            -   name: Install Python requirements and Create default Conan profile
-                run: |
-                    pip install -r requirements-conan-package.txt
-                    conan profile new default --detect
-                working-directory: .github/workflows/
+      - name: Cache Conan local repository packages (Bash)
+        uses: actions/cache@v3
+        if: ${{ runner.os != 'Windows' }}
+        with:
+          path: |
+            $HOME/.conan/data
+            $HOME/.conan/conan_download_cache
+          key: conan-${{ runner.os }}-${{ runner.arch }}-unit-cache
 
-            -   name: Use Conan download cache (Bash)
-                if: ${{ runner.os != 'Windows' }}
-                run: conan config set storage.download_cache="$HOME/.conan/conan_download_cache"
+      # NOTE: Due to what are probably github issues, we have to remove the cache and reconfigure before the rest.
+      #       This is maybe because grub caches the disk it uses last time, which is recreated each time.
+      - name: Install Linux system requirements
+        if: ${{ runner.os == 'Linux' }}
+        run: |
+          sudo rm /var/cache/debconf/config.dat
+          sudo dpkg --configure -a
+          sudo add-apt-repository ppa:ubuntu-toolchain-r/test -y
+          sudo apt update
+          sudo apt upgrade
+          sudo apt install build-essential checkinstall libegl-dev zlib1g-dev libssl-dev ninja-build autoconf libx11-dev libx11-xcb-dev libfontenc-dev libice-dev libsm-dev libxau-dev libxaw7-dev libxcomposite-dev libxcursor-dev libxdamage-dev libxdmcp-dev libxext-dev libxfixes-dev libxi-dev libxinerama-dev libxkbfile-dev libxmu-dev libxmuu-dev libxpm-dev libxrandr-dev libxrender-dev libxres-dev libxss-dev libxt-dev libxtst-dev libxv-dev libxvmc-dev libxxf86vm-dev xtrans-dev libxcb-render0-dev libxcb-render-util0-dev libxcb-xkb-dev libxcb-icccm4-dev libxcb-image0-dev libxcb-keysyms1-dev libxcb-randr0-dev libxcb-shape0-dev libxcb-sync-dev libxcb-xfixes0-dev libxcb-xinerama0-dev xkb-data libxcb-dri3-dev uuid-dev libxcb-util-dev libxkbcommon-x11-dev pkg-config -y
 
-            -   name: Cache Conan local repository packages (Bash)
-                uses: actions/cache@v3
-                if: ${{ runner.os != 'Windows' }}
-                with:
-                    path: |
-                        $HOME/.conan/data
-                        $HOME/.conan/conan_download_cache
-                    key: conan-${{ runner.os }}-${{ runner.arch }}-unit-cache
+      - name: Install GCC-13
+        run: |
+          sudo apt install g++-13 gcc-13 -y
+          sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-13 13
+          sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-13 13
 
-            -   name: Install Linux system requirements
-                if: ${{ runner.os == 'Linux' }}
-                run: |
-                    sudo apt update
-                    sudo apt upgrade
-                    sudo apt install build-essential checkinstall libegl-dev zlib1g-dev libssl-dev ninja-build autoconf libx11-dev libx11-xcb-dev libfontenc-dev libice-dev libsm-dev libxau-dev libxaw7-dev libxcomposite-dev libxcursor-dev libxdamage-dev libxdmcp-dev libxext-dev libxfixes-dev libxi-dev libxinerama-dev libxkbfile-dev libxmu-dev libxmuu-dev libxpm-dev libxrandr-dev libxrender-dev libxres-dev libxss-dev libxt-dev libxtst-dev libxv-dev libxvmc-dev libxxf86vm-dev xtrans-dev libxcb-render0-dev libxcb-render-util0-dev libxcb-xkb-dev libxcb-icccm4-dev libxcb-image0-dev libxcb-keysyms1-dev libxcb-randr0-dev libxcb-shape0-dev libxcb-sync-dev libxcb-xfixes0-dev libxcb-xinerama0-dev xkb-data libxcb-dri3-dev uuid-dev libxcb-util-dev libxkbcommon-x11-dev pkg-config -y
+      - name: Get Conan configuration
+        run: |
+          conan config install https://github.com/Ultimaker/conan-config.git
+          conan config install https://github.com/Ultimaker/conan-config.git -a "-b runner/${{ runner.os }}/${{ runner.arch }}"
 
-            -   name: Use GCC-10 on ubuntu-20.04
-                run: |
-                    sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-10 10
-                    sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-10 10
+      - name: Get Conan profile
+        run: conan profile new default --detect --force
 
-            -   name: Get Conan configuration
-                run: conan config install https://github.com/Ultimaker/conan-config.git
+      - name: Install dependencies
+        run: conan install . ${{ needs.conan-recipe-version.outputs.recipe_id_full }} --build=missing --update -o cura:devtools=True  -g VirtualPythonEnv -if venv
 
-            -   name: Install dependencies
-                run: conan install . ${{ needs.conan-recipe-version.outputs.recipe_id_full }} --build=missing --update -o cura:devtools=True  -g VirtualPythonEnv -if venv
+      - name: Upload the Dependency package(s)
+        run: conan upload "*" -r cura --all -c
 
-            -   name: Upload the Dependency package(s)
-                run: conan upload "*" -r cura --all -c
+      - name: Set Environment variables for Cura (bash)
+        if: ${{ runner.os != 'Windows' }}
+        run: |
+          . ./venv/bin/activate_github_actions_env.sh
 
-            -   name: Set Environment variables for Cura (bash)
-                if: ${{ runner.os != 'Windows' }}
-                run: |
-                    . ./venv/bin/activate_github_actions_env.sh
+      - name: Run Unit Test
+        id: run-test
+        run: |
+          pytest --junitxml=junit_cura.xml
+        working-directory: tests
 
-            -   name: Run Unit Test
-                id: run-test
-                run: |
-                    pytest --junitxml=junit_cura.xml
-                working-directory: tests
+      - name: Save PR metadata
+        if: always()
+        run: |
+          echo ${{ github.event.number }} > pr-id.txt
+          echo ${{ github.event.pull_request.head.repo.full_name }} > pr-head-repo.txt
+          echo ${{ github.event.pull_request.head.ref }} > pr-head-ref.txt
+        working-directory: tests
 
-            -   name: Save PR metadata
-                if: always()
-                run: |
-                    echo ${{ github.event.number }} > pr-id.txt
-                    echo ${{ github.event.pull_request.head.repo.full_name }} > pr-head-repo.txt
-                    echo ${{ github.event.pull_request.head.ref }} > pr-head-ref.txt
-                working-directory: tests
-
-            -   name: Upload Test Results
-                if: always()
-                uses: actions/upload-artifact@v3
-                with:
-                    name: test-result
-                    path: |
-                        tests/**/*.xml
-                        tests/pr-id.txt
-                        tests/pr-head-repo.txt
-                        tests/pr-head-ref.txt
+      - name: Upload Test Results
+        if: always()
+        uses: actions/upload-artifact@v3
+        with:
+          name: test-result
+          path: |
+            tests/**/*.xml
+            tests/pr-id.txt
+            tests/pr-head-repo.txt
+            tests/pr-head-ref.txt

.github/workflows/update-translation.yml

@@ -0,0 +1,87 @@
+name: update-translations
+
+on:
+  push:
+    paths:
+      - 'plugins/**'
+      - 'resources/**'
+      - 'cura/**'
+      - 'icons/**'
+      - 'tests/**'
+      - 'packaging/**'
+      - '.github/workflows/conan-*.yml'
+      - '.github/workflows/notify.yml'
+      - '.github/workflows/requirements-conan-package.txt'
+      - 'requirements*.txt'
+      - 'conanfile.py'
+      - 'conandata.yml'
+      - 'GitVersion.yml'
+      - '*.jinja'
+    branches:
+      - '[1-9].[0-9]'
+      - '[1-9].[0-9][0-9]'
+    tags:
+      - '[1-9].[0-9].[0-9]*'
+      - '[1-9].[0-9].[0-9]'
+      - '[1-9].[0-9][0-9].[0-9]*'
+
+jobs:
+  update-translations:
+    name: Update translations
+
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+
+      - name: Cache Conan data
+        id: cache-conan
+        uses: actions/cache@v3
+        with:
+          path: ~/.conan
+          key: ${{ runner.os }}-conan
+
+      - name: Setup Python and pip
+        uses: actions/setup-python@v4
+        with:
+          python-version: 3.11.x
+          cache: pip
+          cache-dependency-path: .github/workflows/requirements-conan-package.txt
+
+      - name: Install Python requirements for runner
+        run: pip install -r .github/workflows/requirements-conan-package.txt
+
+      # NOTE: Due to what are probably github issues, we have to remove the cache and reconfigure before the rest.
+      #       This is maybe because grub caches the disk it uses last time, which is recreated each time.
+      - name: Install Linux system requirements
+        if: ${{ runner.os == 'Linux' }}
+        run: |
+          sudo rm /var/cache/debconf/config.dat
+          sudo dpkg --configure -a
+          sudo add-apt-repository ppa:ubuntu-toolchain-r/test -y
+          sudo apt update
+          sudo apt upgrade
+          sudo apt install efibootmgr build-essential checkinstall libegl-dev zlib1g-dev libssl-dev ninja-build autoconf libx11-dev libx11-xcb-dev libfontenc-dev libice-dev libsm-dev libxau-dev libxaw7-dev libxcomposite-dev libxcursor-dev libxdamage-dev libxdmcp-dev libxext-dev libxfixes-dev libxi-dev libxinerama-dev libxkbfile-dev libxmu-dev libxmuu-dev libxpm-dev libxrandr-dev libxrender-dev libxres-dev libxss-dev libxt-dev libxtst-dev libxv-dev libxvmc-dev libxxf86vm-dev xtrans-dev libxcb-render0-dev libxcb-render-util0-dev libxcb-xkb-dev libxcb-icccm4-dev libxcb-image0-dev libxcb-keysyms1-dev libxcb-randr0-dev libxcb-shape0-dev libxcb-sync-dev libxcb-xfixes0-dev libxcb-xinerama0-dev xkb-data libxcb-dri3-dev uuid-dev libxcb-util-dev libxkbcommon-x11-dev pkg-config flex bison g++-12 gcc-12 -y
+
+      - name: Install GCC-13
+        run: |
+          sudo apt install g++-13 gcc-13 -y
+          sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-13 13
+          sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-13 13
+
+      - name: Create the default Conan profile
+        run: conan profile new default --detect --force
+
+      - name: Get Conan configuration
+        run: |
+          conan config install https://github.com/Ultimaker/conan-config.git
+          conan config install https://github.com/Ultimaker/conan-config.git -a "-b runner/${{ runner.os }}/${{ runner.arch }}"
+
+      - name: generate the files using Conan install
+        run: conan install . --build=missing --update -o cura:devtools=True
+
+      - uses: stefanzweifel/git-auto-commit-action@v4
+        with:
+          file_pattern: resources/i18n/*.po resources/i18n/*.pot
+          status_options: --untracked-files=no
+          commit_message: update translations

.github/workflows/windows.yml

@@ -0,0 +1,287 @@
+name: Windows Installer
+run-name: ${{ inputs.cura_conan_version }} for Windows-${{ inputs.architecture }} by @${{ github.actor }}
+
+on:
+  workflow_dispatch:
+    inputs:
+      cura_conan_version:
+        description: 'Cura Conan Version'
+        default: 'cura/latest@ultimaker/testing'
+        required: true
+        type: string
+      conan_args:
+        description: 'Conan args: eq.: --require-override'
+        default: ''
+        required: false
+        type: string
+      enterprise:
+        description: 'Build Cura as an Enterprise edition'
+        default: false
+        required: true
+        type: boolean
+      staging:
+        description: 'Use staging API'
+        default: false
+        required: true
+        type: boolean
+      architecture:
+        description: 'Architecture'
+        required: true
+        default: 'X64'
+        type: choice
+        options:
+          - X64
+      operating_system:
+        description: 'OS'
+        required: true
+        default: 'windows-2022'
+        type: choice
+        options:
+          - windows-2022
+  workflow_call:
+    inputs:
+      cura_conan_version:
+        description: 'Cura Conan Version'
+        default: 'cura/latest@ultimaker/testing'
+        required: true
+        type: string
+      conan_args:
+        description: 'Conan args: eq.: --require-override'
+        default: ''
+        required: false
+        type: string
+      enterprise:
+        description: 'Build Cura as an Enterprise edition'
+        default: false
+        required: true
+        type: boolean
+      staging:
+        description: 'Use staging API'
+        default: false
+        required: true
+        type: boolean
+      architecture:
+        description: 'Architecture'
+        required: true
+        default: 'X64'
+        type: string
+      operating_system:
+        description: 'OS'
+        required: true
+        default: 'windows-2022'
+        type: string
+
+env:
+  CONAN_LOGIN_USERNAME_CURA: ${{ secrets.CONAN_USER }}
+  CONAN_PASSWORD_CURA: ${{ secrets.CONAN_PASS }}
+  WIN_CERT_INSTALLER_CER: ${{ secrets.WIN_CERT_INSTALLER_CER }}
+  WIN_CERT_INSTALLER_CER_PASS: ${{ secrets.WIN_CERT_INSTALLER_CER_PASS }}
+  CURA_CONAN_VERSION: ${{ inputs.cura_conan_version }}
+  ENTERPRISE: ${{ inputs.enterprise }}
+  STAGING: ${{ inputs.staging }}
+
+jobs:
+  cura-installer-create:
+    runs-on: ${{ inputs.operating_system }}
+
+    outputs:
+      INSTALLER_FILENAME: ${{ steps.filename.outputs.INSTALLER_FILENAME }}
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+
+      - name: Setup Python and pip
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.10.x'
+          cache: 'pip'
+          cache-dependency-path: .github/workflows/requirements-conan-package.txt
+
+      - name: Install Python requirements for runner
+        run: pip install -r .github/workflows/requirements-conan-package.txt
+
+      - name: Cache Conan local repository packages (Powershell)
+        uses: actions/cache@v3
+        with:
+          path: |
+            C:\Users\runneradmin\.conan\data
+            C:\.conan
+            C:\Users\runneradmin\.conan\conan_download_cache
+          key: conan-${{ runner.os }}-${{ runner.arch }}-installer-cache
+
+      - name: Create the default Conan profile
+        run: conan profile new default --detect --force
+
+      - name: Get Conan configuration
+        run: |
+          conan config install https://github.com/Ultimaker/conan-config.git
+          conan config install https://github.com/Ultimaker/conan-config.git -a "-b runner/${{ runner.os }}/${{ runner.arch }}"
+
+      - name: Use Conan download cache (Powershell)
+        run: conan config set storage.download_cache="C:\Users\runneradmin\.conan\conan_download_cache"
+
+      - name: Create the Packages (Powershell)
+        run: conan install $Env:CURA_CONAN_VERSION ${{ inputs.conan_args }} --build=missing --update -if cura_inst -g VirtualPythonEnv -o cura:enterprise=$Env:ENTERPRISE -o cura:staging=$Env:STAGING --json "cura_inst/conan_install_info.json"
+
+      - name: Upload the Package(s)
+        if: always()
+        run: |
+          conan upload "*" -r cura --all -c
+
+      - name: Set Environment variables for Cura (Powershell)
+        run: |
+          echo "${Env:WIX}\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
+          .\cura_inst\Scripts\activate_github_actions_env.ps1
+          .\cura_inst\Scripts\activate_github_actions_version_env.ps1
+
+      - name: Install OpenSSL shared
+        run: conan install openssl/1.1.1l@_/_ --build=missing --update -o openssl:shared=True -g deploy
+
+      - name: Copy OpenSSL shared (Powershell)
+        run: |
+          cp openssl/bin/*.dll ./cura_inst/Scripts/
+          cp openssl/lib/*.lib ./cura_inst/Lib/
+
+      - name: Create the Cura dist
+        run: pyinstaller ./cura_inst/UltiMaker-Cura.spec
+
+      - name: Output the name file name and extension
+        id: filename
+        shell: python
+        run: |
+          import os
+          enterprise = "-Enterprise" if "${{ inputs.enterprise }}" == "true" else ""
+          installer_filename = f"UltiMaker-Cura-{os.getenv('CURA_VERSION_FULL')}{enterprise}-win64-${{ inputs.architecture }}"
+          output_env = os.environ["GITHUB_OUTPUT"]
+          content = ""
+          if os.path.exists(output_env):
+              with open(output_env, "r") as f:
+                  content = f.read()
+          with open(output_env, "w") as f:
+              f.write(content)
+              f.writelines(f"INSTALLER_FILENAME={installer_filename}\n")
+
+      - name: Summarize the used Conan dependencies
+        shell: python
+        run: |
+          import os
+          import json
+          from pathlib import Path
+          
+          conan_install_info_path = Path("cura_inst/conan_install_info.json")
+          conan_info = {"installed": []}
+          if os.path.exists(conan_install_info_path):
+              with open(conan_install_info_path, "r") as f:
+                  conan_info = json.load(f)
+          sorted_deps = sorted([dep["recipe"]["id"].replace('#', r' rev: ') for dep in conan_info["installed"]])
+          
+          summary_env = os.environ["GITHUB_STEP_SUMMARY"]
+          content = ""
+          if os.path.exists(summary_env):
+              with open(summary_env, "r") as f:
+                  content = f.read()
+          
+          with open(summary_env, "w") as f:
+              f.write(content)
+              f.writelines("# ${{ steps.filename.outputs.INSTALLER_FILENAME }}\n")
+              f.writelines("## Conan packages:\n")
+              for dep in sorted_deps:
+                  f.writelines(f"`{dep}`\n")
+
+      - name: Summarize the used Python modules
+        shell: python
+        run: |
+          import os
+          import pkg_resources
+          summary_env = os.environ["GITHUB_STEP_SUMMARY"]
+          content = ""
+          if os.path.exists(summary_env):
+              with open(summary_env, "r") as f:
+                  content = f.read()
+          
+          with open(summary_env, "w") as f:
+              f.write(content)
+              f.writelines("## Python modules:\n")
+              for package in pkg_resources.working_set:
+                  f.writelines(f"`{package.key}/{package.version}`\n")
+
+      - name: Create PFX certificate from BASE64_PFX_CONTENT secret
+        id: create-pfx
+        env:
+          PFX_CONTENT: ${{ secrets.WIN_CERT_INSTALLER_CER }}
+        run: |
+          $pfxPath = Join-Path -Path $env:RUNNER_TEMP -ChildPath "cert.pfx"; 
+          $encodedBytes = [System.Convert]::FromBase64String($env:PFX_CONTENT); 
+          Set-Content $pfxPath -Value $encodedBytes -AsByteStream;
+          echo "PFX_PATH=$pfxPath" >> $env:GITHUB_OUTPUT;
+
+      - name: Create the Windows msi installer (Powershell)
+        run: |
+          python ..\cura_inst\packaging\msi\create_windows_msi.py ..\cura_inst .\UltiMaker-Cura "${{steps.filename.outputs.INSTALLER_FILENAME }}.msi" "$Env:CURA_APP_NAME"
+        working-directory: dist
+
+      - name: Sign the Windows msi installer (Powershell)
+        env:
+          PFX_PATH: ${{ steps.create-pfx.outputs.PFX_PATH }}
+        run: |
+          & "C:/Program Files (x86)/Windows Kits/10/bin/10.0.17763.0/x86/signtool.exe" sign /f $Env:PFX_PATH /p "$Env:WIN_CERT_INSTALLER_CER_PASS" /fd SHA256 /t http://timestamp.digicert.com "${{steps.filename.outputs.INSTALLER_FILENAME }}.msi"
+        working-directory: dist
+
+      - name: Create the Windows exe installer (Powershell)
+        run: |
+          python ..\cura_inst\packaging\NSIS\create_windows_installer.py ../cura_inst . "${{steps.filename.outputs.INSTALLER_FILENAME }}.exe"
+        working-directory: dist
+
+      - name: Sign the Windows exe installer (Powershell)
+        env:
+          PFX_PATH: ${{ steps.create-pfx.outputs.PFX_PATH }}
+        run: |
+          & "C:/Program Files (x86)/Windows Kits/10/bin/10.0.17763.0/x86/signtool.exe" sign /f $Env:PFX_PATH /p "$Env:WIN_CERT_INSTALLER_CER_PASS" /fd SHA256 /t http://timestamp.digicert.com "${{steps.filename.outputs.INSTALLER_FILENAME }}.exe"
+        working-directory: dist
+
+      - name: Upload the msi
+        uses: actions/upload-artifact@v3
+        with:
+          name: ${{steps.filename.outputs.INSTALLER_FILENAME }}-msi
+          path: |
+            dist/${{steps.filename.outputs.INSTALLER_FILENAME }}.msi
+          retention-days: 5
+
+      - name: Upload the exe
+        uses: actions/upload-artifact@v3
+        with:
+          name: ${{steps.filename.outputs.INSTALLER_FILENAME }}-exe
+          path: |
+            dist/${{steps.filename.outputs.INSTALLER_FILENAME }}.exe
+          retention-days: 5
+
+      # NOTE: The extension is .sh, since this isn't going to build-environment, so not on the Win build image.
+      - name: Write the run info
+        shell: python
+        run: |
+          import os
+          with open("run_info.sh", "w") as f:
+              f.writelines(f'echo "CURA_VERSION_FULL={os.environ["CURA_VERSION_FULL"]}" >> $GITHUB_ENV\n')
+
+      # NOTE: The extension is .sh, since this isn't going to build-environment, so not on the Win build image.
+      - name: Upload the run info
+        uses: actions/upload-artifact@v3
+        with:
+          name: windows-run-info
+          path: |
+            run_info.sh
+          retention-days: 5
+
+  notify-export:
+    if: ${{ always() }}
+    needs: [ cura-installer-create ]
+
+    uses: ultimaker/cura/.github/workflows/notify.yml@main
+    with:
+      success: ${{ contains(join(needs.*.result, ','), 'success') }}
+      success_title: "Create the Cura distributions"
+      success_body: "Installers for ${{ inputs.cura_conan_version }}"
+      failure_title: "Failed to create the Cura distributions"
+      failure_body: "Failed to create at least 1 installer for ${{ inputs.cura_conan_version }}"
+    secrets: inherit

.gitignore

@@ -31,6 +31,7 @@ LC_MESSAGES
 .directory
 .idea
 cura.desktop
+*.bak
 
 # Eclipse+PyDev
 .project
@@ -100,3 +101,8 @@ graph_info.json
 Ultimaker-Cura.spec
 .run/
 /printer-linter/src/printerlinter.egg-info/
+/resources/qml/Dialogs/AboutDialogVersionsList.qml
+/plugins/CuraEngineGradualFlow
+/resources/bundled_packages/bundled_*.json
+curaengine_plugin_gradual_flow
+curaengine_plugin_gradual_flow.exe

.printer-linter

@@ -2,6 +2,7 @@ checks:
     diagnostic-mesh-file-extension: true
     diagnostic-mesh-file-size: true
     diagnostic-definition-redundant-override: true
+    diagnostic-resources-macos-app-directory-name: true
 fixes:
     diagnostic-definition-redundant-override: true
 format:

AboutDialogVersionsList.qml.jinja

@@ -0,0 +1,61 @@
+import QtQuick 2.2
+import QtQuick.Controls 2.9
+
+import UM 1.6 as UM
+import Cura 1.5 as Cura
+
+
+ListView
+{
+    id: projectBuildInfoList
+    visible: false
+    anchors.top: creditsNotes.bottom
+    anchors.topMargin: UM.Theme.getSize("default_margin").height
+    width: parent.width
+    height: base.height - y - (2 * UM.Theme.getSize("default_margin").height + closeButton.height)
+
+    ScrollBar.vertical: UM.ScrollBar
+    {
+        id: projectBuildInfoListScrollBar
+    }
+
+    delegate: Row
+    {
+        spacing: UM.Theme.getSize("narrow_margin").width
+        UM.Label
+        {
+            text: (model.name)
+            width: (projectBuildInfoList.width* 0.4) | 0
+            elide: Text.ElideRight
+        }
+        UM.Label
+        {
+            text: (model.version)
+            width: (projectBuildInfoList.width *0.6) | 0
+            elide: Text.ElideRight
+        }
+
+    }
+    model: ListModel
+    {
+        id: developerInfo
+    }
+    Component.onCompleted:
+    {
+        var conan_installs = {{ conan_installs }};
+        var python_installs = {{ python_installs }};
+        developerInfo.append({ name : "<H1>Conan Installs</H1>", version : '' });
+        for (var n in conan_installs)
+        {
+            developerInfo.append({ name : conan_installs[n][0], version : conan_installs[n][1] });
+        }
+        developerInfo.append({ name : '', version : '' });
+        developerInfo.append({ name : "<H1>Python Installs</H1>", version : '' });
+        for (var n in python_installs)
+        {
+            developerInfo.append({ name : python_installs[n][0], version : python_installs[n][1] });
+        }
+
+    }
+}
+

CITATION.cff

@@ -18,8 +18,8 @@ url: "https://ultimaker.com/software/ultimaker-cura"
 repository-code: "https://github.com/Ultimaker/Cura"
 license: LGPL-3.0
 license-url: "https://github.com/Ultimaker/Cura/blob/main/LICENSE"
-version: 5.2.1
-date-released: "2022-10-19"
+version: 5.4.0
+date-released: "2023-07-04"
 keywords:
   - Ultimaker
   - Cura

CONTRIBUTING.md

@@ -1,6 +1,6 @@
 Submitting bug reports
 ----------------------
-Please submit bug reports for all of Cura and CuraEngine to the [Cura repository](https://github.com/Ultimaker/Cura/issues). There will be a template there to fill in. Depending on the type of issue, we will usually ask for the [Cura log](Logging Issues) or a project file.
+Please submit bug reports for all of Cura and CuraEngine to the [Cura repository](https://github.com/Ultimaker/Cura/issues). There will be a template there to fill in. Depending on the type of issue, we will usually ask for the [Cura log](https://github.com/Ultimaker/Cura/wiki/Reporting#cura-log) or a project file.
 
 If a bug report would contain private information, such as a proprietary 3D model, you may also e-mail us. Ask for contact information in the issue.
 
@@ -8,14 +8,22 @@ Bugs related to supporting certain types of printers can usually not be solved b
 
 Requesting features
 -------------------
-The issue template in the Cura repository does not apply to feature requests. You can ignore it.
-
 When requesting a feature, please describe clearly what you need and why you think this is valuable to users or what problem it solves.
 
 Making pull requests
 --------------------
-If you want to propose a change to Cura's source code, please create a pull request in the appropriate repository (being [Cura](https://github.com/Ultimaker/Cura), [Uranium](https://github.com/Ultimaker/Uranium), [CuraEngine](https://github.com/Ultimaker/CuraEngine), [fdm_materials](https://github.com/Ultimaker/fdm_materials), [libArcus](https://github.com/Ultimaker/libArcus), [cura-build](https://github.com/Ultimaker/cura-build), [cura-build-environment](https://github.com/Ultimaker/cura-build-environment), [libSavitar](https://github.com/Ultimaker/libSavitar), [libCharon](https://github.com/Ultimaker/libCharon) or [cura-binary-data](https://github.com/Ultimaker/cura-binary-data)) and if your change requires changes on multiple of these repositories, please link them together so that we know to merge them together.
+If you want to propose a change to Cura's source code, please create a pull request in the appropriate repository. Since Cura has multiple repositories that influence it, we've listed the most important ones below:
+* [Cura](https://github.com/Ultimaker/Cura)
+* [Uranium](https://github.com/Ultimaker/Uranium)
+* [CuraEngine](https://github.com/Ultimaker/CuraEngine)
+* [fdm_materials](https://github.com/Ultimaker/fdm_materials)
+* [libArcus](https://github.com/Ultimaker/libArcus)
+* [libSavitar](https://github.com/Ultimaker/libSavitar)
+* [libCharon](https://github.com/Ultimaker/libCharon)
+* [cura-binary-data](https://github.com/Ultimaker/cura-binary-data)) 
+
+If your change requires changes on multiple of these repositories, please link them together so that we know to merge & review them together.
 
 The style guide for code contributions to Cura and other Ultimaker projects can be found [here](https://github.com/Ultimaker/Meta/blob/master/general/generic_code_conventions.md).
 
-Some of these repositories will have automated tests running when you create a pull request, indicated by green check marks or red crosses in the Github web page. If you see a red cross, that means that a test has failed. If the test doesn't fail on the Master branch but does fail on your branch, that indicates that you've probably made a mistake and you need to do that. Click on the cross for more details, or run the test locally by running `cmake . && ctest --verbose`.
+Some of these repositories will have automated tests running when you create a pull request, indicated by green check marks or red crosses in the Github web page. If you see a red cross, that means that a test has failed. If the test doesn't fail on the Main branch but does fail on your branch, that indicates that you've probably made a mistake and you need to do that. Click on the cross for more details, or run the test locally by running `cmake . && ctest --verbose`.

FUNDING.yml

@@ -0,0 +1 @@
+github: [ultimaker]

README.md

@@ -1,4 +1,3 @@
-
 <br>
 
 <div align = center>
@@ -13,7 +12,7 @@
 
 [![Badge Test]][Test]   
 [![Badge Conan]][Conan]   
-
+![Badge Downloads]
 <br>
 <br>
 
@@ -51,6 +50,9 @@
 
 <br>
 
+[![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/Ultimaker/Cura/badge)](https://api.securityscorecards.dev/projects/github.com/Ultimaker/Cura)
+
+<br>
 
 <!----------------------------------------------------------------------------->
 
@@ -82,6 +84,7 @@
 [Badge Conan]: https://img.shields.io/github/workflow/status/Ultimaker/Cura/conan-package?style=for-the-badge&logoColor=white&labelColor=6185aa&color=4c6987&logo=Conan&label=Conan%20Package
 [Badge Test]: https://img.shields.io/github/workflow/status/Ultimaker/Cura/unit-test?style=for-the-badge&logoColor=white&labelColor=4a999d&color=346c6e&logo=Codacy&label=Unit%20Test
 [Badge Size]: https://img.shields.io/github/repo-size/ultimaker/cura?style=for-the-badge&logoColor=white&labelColor=715a97&color=584674&logo=GoogleAnalytics
+[Badge Downloads]: https://img.shields.io/github/downloads-pre/Ultimaker/Cura/latest/total?style=for-the-badge
 
 
 <!---------------------------------[ Buttons ]--------------------------------->

conandata.yml

@@ -1,235 +1,116 @@
----
-# Usage: defaults to the first entry in this conandata.yml file
-# If you're on a release branch create an entry for that **version**  e.q.: `5.1.0` update the requirements (use pinned versions, not latest)
-# also create a beta entry for that **version**  e.q.: `5.1.0-beta`, update the requirements (use the <dep_name>/(latest)@ultimaker/stable)
-#
-# If you're working on a feature/bugfix branch from a release branch, create an entry for that **channel**,  update the requirements (use
-# the <dep_name>/(latest)@ultimaker/stable)
-#
-# If you're working on a feature/bugfix branch from a main branch, it is optional to create an entry for that **channel**,  update the
-# requirements (use the <dep_name>/(latest)@ultimaker/testing)
-#
-# Subject to change in the future!
-"5.4.0-alpha":
-  requirements:
-    - "pyarcus/5.2.2"
-    - "curaengine/(latest)@ultimaker/testing"
-    - "pysavitar/5.2.2"
-    - "pynest2d/5.2.2"
-    - "uranium/(latest)@ultimaker/testing"
-    - "fdm_materials/(latest)@ultimaker/testing"
-    - "cura_binary_data/(latest)@ultimaker/testing"
-    - "cpython/3.10.4"
-  internal_requirements:
-    - "fdm_materials_private/(latest)@ultimaker/testing"
-    - "cura_private_data/(latest)@ultimaker/testing"
-  runinfo:
-    entrypoint: "cura_app.py"
-  pyinstaller:
+urls:
+    default:
+        cloud_api_root: "https://api.ultimaker.com"
+        cloud_account_api_root: "https://account.ultimaker.com"
+        marketplace_root: "https://marketplace.ultimaker.com"
+        digital_factory_url: "https://digitalfactory.ultimaker.com"
+        cura_latest_url: "https://software.ultimaker.com/latest.json"
+    staging:
+        cloud_api_root: "https://api-staging.ultimaker.com"
+        cloud_account_api_root: "https://account-staging.ultimaker.com"
+        marketplace_root: "https://marketplace-staging.ultimaker.com"
+        digital_factory_url: "https://digitalfactory-staging.ultimaker.com"
+        cura_latest_url: "https://software.ultimaker.com/latest.json"
+pyinstaller:
+    runinfo:
+        entrypoint: "cura_app.py"
     datas:
-      cura_plugins:
-        package: "cura"
-        src: "plugins"
-        dst: "share/cura/plugins"
-      cura_resources:
-        package: "cura"
-        src: "resources"
-        dst: "share/cura/resources"
-      cura_private_data:
-        package: "cura_private_data"
-        src: "resources"
-        dst: "share/cura/resources"
-        internal: true
-      cura_private_data_plugins:
-        package: "cura_private_data"
-        src: "plugins"
-        dst: "share/cura/plugins"
-        internal: true
-      uranium_plugins:
-        package: "uranium"
-        src: "plugins"
-        dst: "share/uranium/plugins"
-      uranium_resources:
-        package: "uranium"
-        src: "resources"
-        dst: "share/uranium/resources"
-      uranium_um_qt_qml_um:
-        package: "uranium"
-        src: "site-packages/UM/Qt/qml/UM"
-        dst: "PyQt6/Qt6/qml/UM"
-      cura_binary_data:
-        package: "cura_binary_data"
-        src: "resources/cura/resources"
-        dst: "share/cura/resources"
-      uranium_binary_data:
-        package: "cura_binary_data"
-        src: "resources/uranium/resources"
-        dst: "share/uranium/resources"
-      windows_binary_data:
-        package: "cura_binary_data"
-        src: "windows"
-        dst: "share/windows"
-      fdm_materials:
-        package: "fdm_materials"
-        src: "materials"
-        dst: "share/cura/resources/materials"
-      fdm_materials_private:
-        package: "fdm_materials_private"
-        src: "resources/materials"
-        dst: "share/cura/resources/materials"
-        internal: true
-      tcl:
-        package: "tcl"
-        src: "lib/tcl8.6"
-        dst: "tcl"
-      tk:
-        package: "tk"
-        src: "lib/tk8.6"
-        dst: "tk"
+        cura_plugins:
+            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"
+        cura_resources:
+            package: "cura"
+            src: "resources"
+            dst: "share/cura/resources"
+        cura_private_data:
+            package: "cura_private_data"
+            src: "res"
+            dst: "share/cura"
+            internal: true
+        uranium_plugins:
+            package: "uranium"
+            src: "plugins"
+            dst: "share/uranium/plugins"
+        uranium_resources:
+            package: "uranium"
+            src: "resources"
+            dst: "share/uranium/resources"
+        uranium_um_qt_qml_um:
+            package: "uranium"
+            src: "site-packages/UM/Qt/qml/UM"
+            dst: "PyQt6/Qt6/qml/UM"
+        cura_binary_data:
+            package: "cura_binary_data"
+            src: "resources/cura/resources"
+            dst: "share/cura/resources"
+        uranium_binary_data:
+            package: "cura_binary_data"
+            src: "resources/uranium/resources"
+            dst: "share/uranium/resources"
+        windows_binary_data:
+            package: "cura_binary_data"
+            src: "windows"
+            dst: "share/windows"
+        fdm_materials:
+            package: "fdm_materials"
+            src: "res/resources/materials"
+            dst: "share/cura/resources/materials"
+        tcl:
+            package: "tcl"
+            src: "lib/tcl8.6"
+            dst: "tcl"
+        tk:
+            package: "tk"
+            src: "lib/tk8.6"
+            dst: "tk"
     binaries:
-      curaengine:
-        package: "curaengine"
-        src: "bin"
-        dst: "."
-        binary: "CuraEngine"
+        curaengine:
+            package: "curaengine"
+            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"
-      - "pynest2d"
-      - "PyQt6"
-      - "PyQt6.QtNetwork"
-      - "PyQt6.sip"
-      - "logging.handlers"
-      - "zeroconf"
-      - "fcntl"
-      - "stl"
-      - "serial"
+        - "pySavitar"
+        - "pyArcus"
+        - "pynest2d"
+        - "PyQt6"
+        - "PyQt6.QtNetwork"
+        - "PyQt6.sip"
+        - "logging.handlers"
+        - "zeroconf"
+        - "fcntl"
+        - "stl"
+        - "serial"
     collect_all:
-      - "cura"
-      - "UM"
-      - "serial"
-      - "Charon"
-      - "sqlite3"
-      - "trimesh"
-      - "win32ctypes"
-      - "PyQt6"
-      - "PyQt6.QtNetwork"
-      - "PyQt6.sip"
-      - "stl"
+        - "cura"
+        - "UM"
+        - "serial"
+        - "Charon"
+        - "sqlite3"
+        - "trimesh"
+        - "win32ctypes"
+        - "PyQt6"
+        - "PyQt6.QtNetwork"
+        - "PyQt6.sip"
+        - "stl"
     icon:
-      Windows: "./icons/Cura.ico"
-      Macos: "./icons/cura.icns"
-      Linux: "./icons/cura-128.png"
-"5.3.0":
-  requirements:
-    - "pyarcus/5.2.2"
-    - "curaengine/5.3.0"
-    - "pysavitar/5.2.2"
-    - "pynest2d/5.2.2"
-    - "uranium/5.3.0"
-    - "fdm_materials/5.3.0"
-    - "cura_binary_data/5.3.0"
-    - "cpython/3.10.4"
-  internal_requirements:
-    - "fdm_materials_private/(latest)@ultimaker/testing"
-    - "cura_private_data/(latest)@ultimaker/testing"
-  runinfo:
-    entrypoint: "cura_app.py"
-  pyinstaller:
-    datas:
-      cura_plugins:
-        package: "cura"
-        src: "plugins"
-        dst: "share/cura/plugins"
-      cura_resources:
-        package: "cura"
-        src: "resources"
-        dst: "share/cura/resources"
-      cura_private_data:
-        package: "cura_private_data"
-        src: "resources"
-        dst: "share/cura/resources"
-        internal: true
-      cura_private_data_plugins:
-        package: "cura_private_data"
-        src: "plugins"
-        dst: "share/cura/plugins"
-        internal: true
-      uranium_plugins:
-        package: "uranium"
-        src: "plugins"
-        dst: "share/uranium/plugins"
-      uranium_resources:
-        package: "uranium"
-        src: "resources"
-        dst: "share/uranium/resources"
-      uranium_um_qt_qml_um:
-        package: "uranium"
-        src: "site-packages/UM/Qt/qml/UM"
-        dst: "PyQt6/Qt6/qml/UM"
-      cura_binary_data:
-        package: "cura_binary_data"
-        src: "resources/cura/resources"
-        dst: "share/cura/resources"
-      uranium_binary_data:
-        package: "cura_binary_data"
-        src: "resources/uranium/resources"
-        dst: "share/uranium/resources"
-      windows_binary_data:
-        package: "cura_binary_data"
-        src: "windows"
-        dst: "share/windows"
-      fdm_materials:
-        package: "fdm_materials"
-        src: "materials"
-        dst: "share/cura/resources/materials"
-      fdm_materials_private:
-        package: "fdm_materials_private"
-        src: "resources/materials"
-        dst: "share/cura/resources/materials"
-        internal: true
-      tcl:
-        package: "tcl"
-        src: "lib/tcl8.6"
-        dst: "tcl"
-      tk:
-        package: "tk"
-        src: "lib/tk8.6"
-        dst: "tk"
-    binaries:
-      curaengine:
-        package: "curaengine"
-        src: "bin"
-        dst: "."
-        binary: "CuraEngine"
-    hiddenimports:
-      - "pySavitar"
-      - "pyArcus"
-      - "pynest2d"
-      - "PyQt6"
-      - "PyQt6.QtNetwork"
-      - "PyQt6.sip"
-      - "logging.handlers"
-      - "zeroconf"
-      - "fcntl"
-      - "stl"
-      - "serial"
-    collect_all:
-      - "cura"
-      - "UM"
-      - "serial"
-      - "Charon"
-      - "sqlite3"
-      - "trimesh"
-      - "win32ctypes"
-      - "PyQt6"
-      - "PyQt6.QtNetwork"
-      - "PyQt6.sip"
-      - "stl"
-    icon:
-      Windows: "./icons/Cura.ico"
-      Macos: "./icons/cura.icns"
-      Linux: "./icons/cura-128.png"
+        Windows: "./icons/Cura.ico"
+        Macos: "./icons/cura.icns"
+        Linux: "./icons/cura-128.png"
 pycharm_targets:
   - jinja_path: .run_templates/pycharm_cura_run.run.xml.jinja
     module_name: Cura

conanfile.py

@@ -4,13 +4,13 @@ from pathlib import Path
 from jinja2 import Template
 
 from conan import ConanFile
-from conan.tools.files import copy, rmdir, save, mkdir
+from conan.tools.files import copy, rmdir, save, mkdir, rm
 from conan.tools.microsoft import unix_path
-from conan.tools.env import VirtualRunEnv, Environment
+from conan.tools.env import VirtualRunEnv, Environment, VirtualBuildEnv
 from conan.tools.scm import Version
 from conan.errors import ConanInvalidConfiguration, ConanException
 
-required_conan_version = ">=1.52.0"
+required_conan_version = ">=1.58.0 <2.0.0"
 
 
 class CuraConan(ConanFile):
@@ -19,16 +19,13 @@ class CuraConan(ConanFile):
     author = "UltiMaker"
     url = "https://github.com/Ultimaker/cura"
     description = "3D printer / slicing GUI built on top of the Uranium framework"
-    topics = ("conan", "python", "pyqt5", "qt", "qml", "3d-printing", "slicer")
+    topics = ("conan", "python", "pyqt6", "qt", "qml", "3d-printing", "slicer")
     build_policy = "missing"
-    exports = "LICENSE*", "UltiMaker-Cura.spec.jinja", "CuraVersion.py.jinja"
+    exports = "LICENSE*", "*.jinja"
     settings = "os", "compiler", "build_type", "arch"
-    no_copy_source = True  # We won't build so no need to copy sources to the build folder
 
     # FIXME: Remove specific branch once merged to main
-    # Extending the conanfile with the UMBaseConanfile https://github.com/Ultimaker/conan-ultimaker-index/tree/CURA-9177_Fix_CI_CD/recipes/umbase
-    python_requires = "umbase/[>=0.1.7]@ultimaker/stable", "translationextractor/[>=1.0.0]@ultimaker/stable"
-    python_requires_extend = "umbase.UMBaseConanfile"
+    python_requires = "translationextractor/[>=2.1.1]@ultimaker/stable"
 
     options = {
         "enterprise": ["True", "False", "true", "false"],  # Workaround for GH Action passing boolean as lowercase string
@@ -48,12 +45,10 @@ class CuraConan(ConanFile):
         "cura_debug_mode": False,  # Not yet implemented
         "internal": False,
     }
-    scm = {
-        "type": "git",
-        "subfolder": ".",
-        "url": "auto",
-        "revision": "auto"
-    }
+
+    def set_version(self):
+        if not self.version:
+            self.version = "5.5.0-beta.1"
 
     @property
     def _pycharm_targets(self):
@@ -77,10 +72,6 @@ class CuraConan(ConanFile):
             self._cura_env.define("QT_XKB_CONFIG_ROOT", "/usr/share/X11/xkb")
         return self._cura_env
 
-    @property
-    def _staging(self):
-        return self.options.staging in ["True", 'true']
-
     @property
     def _enterprise(self):
         return self.options.enterprise in ["True", 'true']
@@ -92,24 +83,10 @@ class CuraConan(ConanFile):
         return str(self.options.display_name)
 
     @property
-    def _cloud_api_root(self):
-        return "https://api-staging.ultimaker.com" if self._staging else "https://api.ultimaker.com"
-
-    @property
-    def _cloud_account_api_root(self):
-        return "https://account-staging.ultimaker.com" if self._staging else "https://account.ultimaker.com"
-
-    @property
-    def _marketplace_root(self):
-        return "https://marketplace-staging.ultimaker.com" if self._staging else "https://marketplace.ultimaker.com"
-
-    @property
-    def _digital_factory_url(self):
-        return "https://digitalfactory-staging.ultimaker.com" if self._staging else "https://digitalfactory.ultimaker.com"
-
-    @property
-    def _cura_latest_url(self):
-        return "https://software.ultimaker.com/latest.json"
+    def _urls(self):
+        if self.options.staging in ["True", 'true']:
+            return "staging"
+        return "default"
 
     @property
     def requirements_txts(self):
@@ -152,8 +129,47 @@ class CuraConan(ConanFile):
             py_interp = Path(*[f'"{p}"' if " " in p else p for p in py_interp.parts])
         return py_interp
 
+    @property
+    def _pyinstaller_spec_arch(self):
+        if self.settings.os == "Macos":
+            if self.settings.arch == "armv8":
+                return "'arm64'"
+            return "'x86_64'"
+        return "None"
+
+    def _generate_about_versions(self, location):
+        with open(os.path.join(self.recipe_folder, "AboutDialogVersionsList.qml.jinja"), "r") as f:
+            cura_version_py = Template(f.read())
+
+        conan_installs = []
+        python_installs = []
+
+        # list  of conan installs
+        for _, dependency in self.dependencies.host.items():
+            conan_installs.append([dependency.ref.name,dependency.ref.version])
+
+        #list of python installs
+        outer = '"' if self.settings.os == "Windows" else "'"
+        inner = "'" if self.settings.os == "Windows" else '"'
+        python_ins_cmd = f"python -c {outer}import pkg_resources; print({inner};{inner}.join([(s.key+{inner},{inner}+ s.version) for s in pkg_resources.working_set])){outer}"
+        from six import StringIO
+        buffer = StringIO()
+        self.run(python_ins_cmd, run_environment= True, env = "conanrun",  output=buffer)
+
+        packages = str(buffer.getvalue()).split("-----------------\n")
+        package = packages[1].strip('\r\n').split(";")
+        for pack in package:
+            python_installs.append(pack.split(","))
+
+        with open(os.path.join(location, "AboutDialogVersionsList.qml"), "w") as f:
+            f.write(cura_version_py.render(
+                conan_installs = conan_installs,
+                python_installs = python_installs
+            ))
+
+
     def _generate_cura_version(self, location):
-        with open(Path(__file__).parent.joinpath("CuraVersion.py.jinja"), "r") as f:
+        with open(os.path.join(self.recipe_folder, "CuraVersion.py.jinja"), "r") as f:
             cura_version_py = Template(f.read())
 
         # If you want a specific Cura version to show up on the splash screen add the user configuration `user.cura:version=VERSION`
@@ -164,22 +180,22 @@ class CuraConan(ConanFile):
         internal_tag = f"+internal" if self.options.internal else ""
         cura_version = f"{cura_version.major}.{cura_version.minor}.{cura_version.patch}{pre_tag}{build_tag}{internal_tag}"
 
-        with open(Path(location, "CuraVersion.py"), "w") as f:
+        with open(os.path.join(location, "CuraVersion.py"), "w") as f:
             f.write(cura_version_py.render(
                 cura_app_name = self.name,
                 cura_app_display_name = self._app_name,
                 cura_version = cura_version,
                 cura_build_type = "Enterprise" if self._enterprise else "",
                 cura_debug_mode = self.options.cura_debug_mode,
-                cura_cloud_api_root = self._cloud_api_root,
+                cura_cloud_api_root = self.conan_data["urls"][self._urls]["cloud_api_root"],
                 cura_cloud_api_version = self.options.cloud_api_version,
-                cura_cloud_account_api_root = self._cloud_account_api_root,
-                cura_marketplace_root = self._marketplace_root,
-                cura_digital_factory_url = self._digital_factory_url,
-                cura_latest_url = self._cura_latest_url))
+                cura_cloud_account_api_root = self.conan_data["urls"][self._urls]["cloud_account_api_root"],
+                cura_marketplace_root = self.conan_data["urls"][self._urls]["marketplace_root"],
+                cura_digital_factory_url = self.conan_data["urls"][self._urls]["digital_factory_url"],
+                cura_latest_url = self.conan_data["urls"][self._urls]["cura_latest_url"]))
 
     def _generate_pyinstaller_spec(self, location, entrypoint_location, icon_path, entitlements_file):
-        pyinstaller_metadata = self._um_data()["pyinstaller"]
+        pyinstaller_metadata = self.conan_data["pyinstaller"]
         datas = [(str(self._base_dir.joinpath("conan_install_info.json")), ".")]
         for data in pyinstaller_metadata["datas"].values():
             if not self.options.internal and data.get("internal", False):
@@ -188,33 +204,35 @@ class CuraConan(ConanFile):
             if "package" in data:  # get the paths from conan package
                 if data["package"] == self.name:
                     if self.in_local_cache:
-                        src_path = Path(self.package_folder, data["src"])
+                        src_path = os.path.join(self.package_folder, data["src"])
                     else:
-                        src_path = Path(self.source_folder, data["src"])
+                        src_path = os.path.join(self.source_folder, data["src"])
                 else:
-                    src_path = Path(self.deps_cpp_info[data["package"]].rootpath, data["src"])
-            elif "root" in data:  # get the paths relative from the sourcefolder
-                src_path = Path(self.source_folder, data["root"], data["src"])
+                    src_path = os.path.join(self.deps_cpp_info[data["package"]].rootpath, data["src"])
+            elif "root" in data:  # get the paths relative from the install folder
+                src_path = os.path.join(self.install_folder, data["root"], data["src"])
             else:
                 continue
-            if src_path.exists():
+            if Path(src_path).exists():
                 datas.append((str(src_path), data["dst"]))
 
         binaries = []
         for binary in pyinstaller_metadata["binaries"].values():
             if "package" in binary:  # get the paths from conan package
-                src_path = Path(self.deps_cpp_info[binary["package"]].rootpath, binary["src"])
+                src_path = os.path.join(self.deps_cpp_info[binary["package"]].rootpath, binary["src"])
             elif "root" in binary:  # get the paths relative from the sourcefolder
-                src_path = Path(self.source_folder, binary["root"], binary["src"])
+                src_path = str(self.source_path.joinpath(binary["root"], binary["src"]))
+                if self.settings.os == "Windows":
+                    src_path = src_path.replace("\\", "\\\\")
             else:
                 continue
-            if not src_path.exists():
+            if not Path(src_path).exists():
                 self.output.warning(f"Source path for binary {binary['binary']} does not exist")
                 continue
 
-            for bin in src_path.glob(binary["binary"] + "*[.exe|.dll|.so|.dylib|.so.]*"):
+            for bin in Path(src_path).glob(binary["binary"] + "*[.exe|.dll|.so|.dylib|.so.]*"):
                 binaries.append((str(bin), binary["dst"]))
-            for bin in src_path.glob(binary["binary"]):
+            for bin in Path(src_path).glob(binary["binary"]):
                 binaries.append((str(bin), binary["dst"]))
 
         # Make sure all Conan dependencies which are shared are added to the binary list for pyinstaller
@@ -232,13 +250,13 @@ class CuraConan(ConanFile):
         # Collect all dll's from PyQt6 and place them in the root
         binaries.extend([(f"{p}", ".") for p in Path(self._site_packages, "PyQt6", "Qt6").glob("**/*.dll")])
 
-        with open(Path(__file__).parent.joinpath("UltiMaker-Cura.spec.jinja"), "r") as f:
+        with open(os.path.join(self.recipe_folder, "UltiMaker-Cura.spec.jinja"), "r") as f:
             pyinstaller = Template(f.read())
 
         version = self.conf_info.get("user.cura:version", default = self.version, check_type = str)
         cura_version = Version(version)
 
-        with open(Path(location, "UltiMaker-Cura.spec"), "w") as f:
+        with open(os.path.join(location, "UltiMaker-Cura.spec"), "w") as f:
             f.write(pyinstaller.render(
                 name = str(self.options.display_name).replace(" ", "-"),
                 display_name = self._app_name,
@@ -253,21 +271,32 @@ class CuraConan(ConanFile):
                 osx_bundle_identifier = "'nl.ultimaker.cura'" if self.settings.os == "Macos" else "None",
                 upx = str(self.settings.os == "Windows"),
                 strip = False,  # This should be possible on Linux and MacOS but, it can also cause issues on some distributions. Safest is to disable it for now
-                target_arch = "'x86_64'" if self.settings.os == "Macos" else "None",  # FIXME: Make this dependent on the settings.arch_target
+                target_arch = self._pyinstaller_spec_arch,
                 macos = self.settings.os == "Macos",
                 version = f"'{version}'",
                 short_version = f"'{cura_version.major}.{cura_version.minor}.{cura_version.patch}'",
             ))
 
-    def set_version(self):
-        if self.version is None:
-            self.version = self._umdefault_version()
+    def export_sources(self):
+        copy(self, "*", os.path.join(self.recipe_folder, "plugins"), os.path.join(self.export_sources_folder, "plugins"))
+        copy(self, "*", os.path.join(self.recipe_folder, "resources"), os.path.join(self.export_sources_folder, "resources"), excludes = "*.mo")
+        copy(self, "*", os.path.join(self.recipe_folder, "tests"), os.path.join(self.export_sources_folder, "tests"))
+        copy(self, "*", os.path.join(self.recipe_folder, "cura"), os.path.join(self.export_sources_folder, "cura"), excludes="CuraVersion.py")
+        copy(self, "*", os.path.join(self.recipe_folder, "packaging"), os.path.join(self.export_sources_folder, "packaging"))
+        copy(self, "*", os.path.join(self.recipe_folder, ".run_templates"), os.path.join(self.export_sources_folder, ".run_templates"))
+        copy(self, "requirements.txt", self.recipe_folder, self.export_sources_folder)
+        copy(self, "requirements-dev.txt", self.recipe_folder, self.export_sources_folder)
+        copy(self, "requirements-ultimaker.txt", self.recipe_folder, self.export_sources_folder)
+        copy(self, "cura_app.py", self.recipe_folder, self.export_sources_folder)
 
     def configure(self):
         self.options["pyarcus"].shared = True
         self.options["pysavitar"].shared = True
         self.options["pynest2d"].shared = True
         self.options["cpython"].shared = True
+        self.options["boost"].header_only = True
+        if self.settings.os == "Linux":
+            self.options["curaengine_grpc_definitions"].shared = True
 
     def validate(self):
         version = self.conf_info.get("user.cura:version", default = self.version, check_type = str)
@@ -275,149 +304,130 @@ class CuraConan(ConanFile):
             raise ConanInvalidConfiguration("Only versions 5+ are support")
 
     def requirements(self):
-        for req in self._um_data()["requirements"]:
-            self.requires(req)
+        self.requires("boost/1.82.0")
+        self.requires("curaengine_grpc_definitions/latest@ultimaker/testing")
+        self.requires("zlib/1.2.13")
+        self.requires("pyarcus/5.3.0")
+        self.requires("curaengine/(latest)@ultimaker/stable")
+        self.requires("pysavitar/5.3.0")
+        self.requires("pynest2d/5.3.0")
+        self.requires("curaengine_plugin_gradual_flow/(latest)@ultimaker/testing")
+        self.requires("uranium/(latest)@ultimaker/stable")
+        self.requires("cura_binary_data/(latest)@ultimaker/stable")
+        self.requires("cpython/3.10.4")
         if self.options.internal:
-            for req in self._um_data()["internal_requirements"]:
-                self.requires(req)
+            self.requires("cura_private_data/(latest)@ultimaker/testing")
+            self.requires("fdm_materials/(latest)@internal/testing")
+        else:
+            self.requires("fdm_materials/(latest)@ultimaker/stable")
 
     def build_requirements(self):
         if self.options.devtools:
             if self.settings.os != "Windows" or self.conf.get("tools.microsoft.bash:path", check_type = str):
                 # FIXME: once m4, autoconf, automake are Conan V2 ready use self.win_bash and add gettext as base tool_requirement
-                self.tool_requires("gettext/0.21", force_host_context=True)
+                self.tool_requires("gettext/0.21@ultimaker/testing", force_host_context = True)
 
     def layout(self):
         self.folders.source = "."
         self.folders.build = "venv"
-        self.folders.generators = Path(self.folders.build, "conan")
+        self.folders.generators = os.path.join(self.folders.build, "conan")
 
         self.cpp.package.libdirs = [os.path.join("site-packages", "cura")]
         self.cpp.package.bindirs = ["bin"]
         self.cpp.package.resdirs = ["resources", "plugins", "packaging", "pip_requirements"]  # pip_requirements should be the last item in the list
 
-    def build(self):
-        if self.options.devtools:
-            if self.settings.os != "Windows" or self.conf.get("tools.microsoft.bash:path", check_type = str):
-                # FIXME: once m4, autoconf, automake are Conan V2 ready use self.win_bash and add gettext as base tool_requirement
-                cpp_info = self.dependencies["gettext"].cpp_info
-                for po_file in self.source_path.joinpath("resources", "i18n").glob("**/*.po"):
-                    mo_file = self.build_path.joinpath(po_file.with_suffix('.mo').relative_to(self.source_path))
-                    mkdir(self, str(unix_path(self, mo_file.parent)))
-                    self.run(f"{cpp_info.bindirs[0]}/msgfmt {po_file} -o {mo_file} -f", env="conanbuild", ignore_errors=True)
-
     def generate(self):
+        copy(self, "cura_app.py", self.source_folder, str(self._script_dir))
         cura_run_envvars = self._cura_run_env.vars(self, scope = "run")
         ext = ".ps1" if self.settings.os == "Windows" else ".sh"
-        cura_run_envvars.save_script(self.folders.generators.joinpath(f"cura_run_environment{ext}"))
+        cura_run_envvars.save_script(os.path.join(self.folders.generators, f"cura_run_environment{ext}"))
 
         vr = VirtualRunEnv(self)
         vr.generate()
 
-        self._generate_cura_version(Path(self.source_folder, "cura"))
+        self._generate_cura_version(os.path.join(self.source_folder, "cura"))
+        self._generate_about_versions(os.path.join(self.source_folder, "resources","qml", "Dialogs"))
 
-        if self.options.devtools:
-            entitlements_file = "'{}'".format(Path(self.source_folder, "packaging", "MacOS", "cura.entitlements"))
-            self._generate_pyinstaller_spec(location = self.generators_folder,
-                                            entrypoint_location = "'{}'".format(Path(self.source_folder, self._um_data()["runinfo"]["entrypoint"])).replace("\\", "\\\\"),
-                                            icon_path = "'{}'".format(Path(self.source_folder, "packaging", self._um_data()["pyinstaller"]["icon"][str(self.settings.os)])).replace("\\", "\\\\"),
-                                            entitlements_file = entitlements_file if self.settings.os == "Macos" else "None")
+        if not self.in_local_cache:
+            # Copy CuraEngine.exe to bindirs of Virtual Python Environment
+            curaengine = self.dependencies["curaengine"].cpp_info
+            copy(self, "CuraEngine.exe", curaengine.bindirs[0], self.source_folder, keep_path = False)
+            copy(self, "CuraEngine", curaengine.bindirs[0], self.source_folder, keep_path = False)
 
-            # Update the po files
-            if self.settings.os != "Windows" or self.conf.get("tools.microsoft.bash:path", check_type = str):
-                # FIXME: once m4, autoconf, automake are Conan V2 ready use self.win_bash and add gettext as base tool_requirement
-                # Extract all the new strings and update the existing po files
-                extractTool = self.python_requires["translationextractor"].module.ExtractTranslations(self, self.source_path.joinpath("resources", "i18n"), "cura.pot")
-                extractTool.generate()
-
-    def imports(self):
-        self.copy("CuraEngine.exe", root_package = "curaengine", src = "@bindirs", dst = "", keep_path = False)
-        self.copy("CuraEngine", root_package = "curaengine", src = "@bindirs", dst = "", keep_path = False)
-
-        rmdir(self, os.path.join(self.source_folder, "resources", "materials"))
-        self.copy("*.fdm_material", root_package = "fdm_materials", src = "@resdirs", dst = "resources/materials", keep_path = False)
-        self.copy("*.sig", root_package = "fdm_materials", src = "@resdirs", dst = "resources/materials", keep_path = False)
-
-        if self.options.internal:
-            self.copy("*.fdm_material", root_package = "fdm_materials_private", src = "@resdirs", dst = "resources/materials", keep_path = False)
-            self.copy("*.sig", root_package = "fdm_materials_private", src = "@resdirs", dst = "resources/materials", keep_path = False)
-            self.copy("*", root_package = "cura_private_data", src = self.deps_cpp_info["cura_private_data"].resdirs[0],
-                           dst = self._share_dir.joinpath("cura", "resources"), keep_path = True)
+            # 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)
 
         # Copy resources of cura_binary_data
-        self.copy("*", root_package = "cura_binary_data", src = self.deps_cpp_info["cura_binary_data"].resdirs[0],
-                       dst = self._share_dir.joinpath("cura", "resources"), keep_path = True)
-        self.copy("*", root_package = "cura_binary_data", src = self.deps_cpp_info["cura_binary_data"].resdirs[1],
-                       dst =self._share_dir.joinpath("uranium", "resources"), keep_path = True)
+        cura_binary_data = self.dependencies["cura_binary_data"].cpp_info
+        copy(self, "*", cura_binary_data.resdirs[0], str(self._share_dir.joinpath("cura")), keep_path = True)
+        copy(self, "*", cura_binary_data.resdirs[1], str(self._share_dir.joinpath("uranium")), keep_path = True)
+        if self.settings.os == "Windows":
+            copy(self, "*", cura_binary_data.resdirs[2], str(self._share_dir.joinpath("windows")), keep_path = True)
 
-        self.copy("*.dll", src = "@bindirs", dst = self._site_packages)
-        self.copy("*.pyd", src = "@libdirs", dst = self._site_packages)
-        self.copy("*.pyi", src = "@libdirs", dst = self._site_packages)
-        self.copy("*.dylib", src = "@libdirs", dst = self._script_dir)
-
-    def deploy(self):
-        # Copy CuraEngine.exe to bindirs of Virtual Python Environment
-        # TODO: Fix source such that it will get the curaengine relative from the executable (Python bindir in this case)
-        self.copy_deps("CuraEngine.exe", root_package = "curaengine", src = self.deps_cpp_info["curaengine"].bindirs[0],
-                       dst = self._base_dir,
-                       keep_path = False)
-        self.copy_deps("CuraEngine", root_package = "curaengine", src = self.deps_cpp_info["curaengine"].bindirs[0], dst = self._base_dir,
-                       keep_path = False)
-
-        # Copy resources of Cura (keep folder structure)
-        self.copy("*", src = self.cpp_info.bindirs[0], dst = self._base_dir, keep_path = False)
-        self.copy("*", src = self.cpp_info.libdirs[0], dst = self._site_packages.joinpath("cura"), keep_path = True)
-        self.copy("*", src = self.cpp_info.resdirs[0], dst = self._share_dir.joinpath("cura", "resources"), keep_path = True)
-        self.copy("*", src = self.cpp_info.resdirs[1], dst = self._share_dir.joinpath("cura", "plugins"), keep_path = True)
+        for dependency in self.dependencies.host.values():
+            for bindir in dependency.cpp_info.bindirs:
+                copy(self, "*.dll", bindir, str(self._site_packages), keep_path = False)
+            for libdir in dependency.cpp_info.libdirs:
+                copy(self, "*.pyd", libdir, str(self._site_packages), keep_path = False)
+                copy(self, "*.pyi", libdir, str(self._site_packages), keep_path = False)
+                copy(self, "*.dylib", libdir, str(self._base_dir.joinpath("lib")), keep_path = False)
 
         # Copy materials (flat)
-        self.copy_deps("*.fdm_material", root_package = "fdm_materials", src = self.deps_cpp_info["fdm_materials"].resdirs[0],
-                       dst = self._share_dir.joinpath("cura", "resources", "materials"), keep_path = False)
-        self.copy_deps("*.sig", root_package = "fdm_materials", src = self.deps_cpp_info["fdm_materials"].resdirs[0],
-                       dst = self._share_dir.joinpath("cura", "resources", "materials"), keep_path = False)
+        rmdir(self, os.path.join(self.source_folder, "resources", "materials"))
+        fdm_materials = self.dependencies["fdm_materials"].cpp_info
+        copy(self, "*", fdm_materials.resdirs[0], self.source_folder)
 
         # Copy internal resources
         if self.options.internal:
-            self.copy_deps("*.fdm_material", root_package = "fdm_materials_private", src = self.deps_cpp_info["fdm_materials_private"].resdirs[0],
-                           dst = self._share_dir.joinpath("cura", "resources", "materials"), keep_path = False)
-            self.copy_deps("*.sig", root_package = "fdm_materials_private", src = self.deps_cpp_info["fdm_materials_private"].resdirs[0],
-                           dst = self._share_dir.joinpath("cura", "resources", "materials"), keep_path = False)
-            self.copy_deps("*", root_package = "cura_private_data", src = self.deps_cpp_info["cura_private_data"].resdirs[0],
-                           dst = self._share_dir.joinpath("cura", "resources"), keep_path = True)
-            self.copy_deps("*", root_package = "cura_private_data", src = self.deps_cpp_info["cura_private_data"].resdirs[1],
-                           dst = self._share_dir.joinpath("cura", "plugins"), keep_path = True)
+            cura_private_data = self.dependencies["cura_private_data"].cpp_info
+            copy(self, "*", cura_private_data.resdirs[0], str(self._share_dir.joinpath("cura")))
+
+        if self.options.devtools:
+            entitlements_file = "'{}'".format(os.path.join(self.source_folder, "packaging", "MacOS", "cura.entitlements"))
+            self._generate_pyinstaller_spec(location = self.generators_folder,
+                                            entrypoint_location = "'{}'".format(os.path.join(self.source_folder, self.conan_data["pyinstaller"]["runinfo"]["entrypoint"])).replace("\\", "\\\\"),
+                                            icon_path = "'{}'".format(os.path.join(self.source_folder, "packaging", self.conan_data["pyinstaller"]["icon"][str(self.settings.os)])).replace("\\", "\\\\"),
+                                            entitlements_file = entitlements_file if self.settings.os == "Macos" else "None")
+
+            # Update the po and pot files
+            if self.settings.os != "Windows" or self.conf.get("tools.microsoft.bash:path", check_type=str):
+                vb = VirtualBuildEnv(self)
+                vb.generate()
+
+                # FIXME: once m4, autoconf, automake are Conan V2 ready use self.win_bash and add gettext as base tool_requirement
+                cpp_info = self.dependencies["gettext"].cpp_info
+                pot = self.python_requires["translationextractor"].module.ExtractTranslations(self, cpp_info.bindirs[0])
+                pot.generate()
+
+    def build(self):
+        if self.options.devtools:
+            if self.settings.os != "Windows" or self.conf.get("tools.microsoft.bash:path", check_type = str):
+                # FIXME: once m4, autoconf, automake are Conan V2 ready use self.win_bash and add gettext as base tool_requirement
+                for po_file in self.source_path.joinpath("resources", "i18n").glob("**/*.po"):
+                    mo_file = Path(self.build_folder, po_file.with_suffix('.mo').relative_to(self.source_path))
+                    mo_file = mo_file.parent.joinpath("LC_MESSAGES", mo_file.name)
+                    mkdir(self, str(unix_path(self, Path(mo_file).parent)))
+                    cpp_info = self.dependencies["gettext"].cpp_info
+                    self.run(f"{cpp_info.bindirs[0]}/msgfmt {po_file} -o {mo_file} -f", env="conanbuild", ignore_errors=True)
+
+    def deploy(self):
+        copy(self, "*", os.path.join(self.package_folder, self.cpp.package.resdirs[2]), os.path.join(self.install_folder, "packaging"), keep_path = True)
+
+        # Copy resources of Cura (keep folder structure) needed by pyinstaller to determine the module structure
+        copy(self, "*", os.path.join(self.package_folder, self.cpp_info.bindirs[0]), str(self._base_dir), keep_path = False)
+        copy(self, "*", os.path.join(self.package_folder, self.cpp_info.libdirs[0]), str(self._site_packages.joinpath("cura")), keep_path = True)
+        copy(self, "*", os.path.join(self.package_folder, self.cpp_info.resdirs[0]), str(self._share_dir.joinpath("cura", "resources")), keep_path = True)
+        copy(self, "*", os.path.join(self.package_folder, self.cpp_info.resdirs[1]), str(self._share_dir.joinpath("cura", "plugins")), keep_path = True)
 
         # Copy resources of Uranium (keep folder structure)
-        self.copy_deps("*", root_package = "uranium", src = self.deps_cpp_info["uranium"].resdirs[0],
-                       dst = self._share_dir.joinpath("uranium", "resources"), keep_path = True)
-        self.copy_deps("*", root_package = "uranium", src = self.deps_cpp_info["uranium"].resdirs[1],
-                       dst = self._share_dir.joinpath("uranium", "plugins"), keep_path = True)
-        self.copy_deps("*", root_package = "uranium", src = self.deps_cpp_info["uranium"].libdirs[0],
-                       dst = self._site_packages.joinpath("UM"),
-                       keep_path = True)
-        self.copy_deps("*", root_package = "uranium", src = str(Path(self.deps_cpp_info["uranium"].libdirs[0], "Qt", "qml", "UM")),
-                       dst = self._site_packages.joinpath("PyQt6", "Qt6", "qml", "UM"),
-                       keep_path = True)
-
-        # Copy resources of cura_binary_data
-        self.copy_deps("*", root_package = "cura_binary_data", src = self.deps_cpp_info["cura_binary_data"].resdirs[0],
-                       dst = self._share_dir.joinpath("cura"), keep_path = True)
-        self.copy_deps("*", root_package = "cura_binary_data", src = self.deps_cpp_info["cura_binary_data"].resdirs[1],
-                       dst = self._share_dir.joinpath("uranium"), keep_path = True)
-        if self.settings.os == "Windows":
-            self.copy_deps("*", root_package = "cura_binary_data", src = self.deps_cpp_info["cura_binary_data"].resdirs[2],
-                           dst = self._share_dir.joinpath("windows"), keep_path = True)
-
-        self.copy_deps("*.dll", src = "@bindirs", dst = self._site_packages)
-        self.copy_deps("*.pyd", src = "@libdirs", dst = self._site_packages)
-        self.copy_deps("*.pyi", src = "@libdirs", dst = self._site_packages)
-        self.copy_deps("*.dylib", src = "@libdirs", dst = self._base_dir.joinpath("lib"))
-
-        # Copy packaging scripts
-        self.copy("*", src = self.cpp_info.resdirs[2], dst = self._base_dir.joinpath("packaging"))
-
-        # Copy requirements.txt's
-        self.copy("*.txt", src = self.cpp_info.resdirs[-1], dst = self._base_dir.joinpath("pip_requirements"))
+        uranium = self.dependencies["uranium"].cpp_info
+        copy(self, "*", uranium.resdirs[0], str(self._share_dir.joinpath("uranium", "resources")), keep_path = True)
+        copy(self, "*", uranium.resdirs[1], str(self._share_dir.joinpath("uranium", "plugins")), keep_path = True)
+        copy(self, "*", uranium.libdirs[0], str(self._site_packages.joinpath("UM")), keep_path = True)
 
         # Generate the GitHub Action version info Environment
         version = self.conf_info.get("user.cura:version", default = self.version, check_type = str)
@@ -438,24 +448,32 @@ echo "CURA_APP_NAME={{ cura_app_name }}" >> ${{ env_prefix }}GITHUB_ENV
                     env_prefix = env_prefix)
 
         ext = ".sh" if self.settings.os != "Windows" else ".ps1"
-        save(self, self._script_dir.joinpath(f"activate_github_actions_version_env{ext}"), activate_github_actions_version_env)
+        save(self, os.path.join(self._script_dir, f"activate_github_actions_version_env{ext}"), activate_github_actions_version_env)
 
-        self._generate_cura_version(Path(self._site_packages, "cura"))
+        self._generate_cura_version(os.path.join(self._site_packages, "cura"))
+        self._generate_about_versions(str(self._share_dir.joinpath("cura", "resources", "qml", "Dialogs")))
 
         entitlements_file = "'{}'".format(Path(self.cpp_info.res_paths[2], "MacOS", "cura.entitlements"))
         self._generate_pyinstaller_spec(location = self._base_dir,
-                                        entrypoint_location = "'{}'".format(Path(self.cpp_info.bin_paths[0], self._um_data()["runinfo"]["entrypoint"])).replace("\\", "\\\\"),
-                                        icon_path = "'{}'".format(Path(self.cpp_info.res_paths[2], self._um_data()["pyinstaller"]["icon"][str(self.settings.os)])).replace("\\", "\\\\"),
+                                        entrypoint_location = "'{}'".format(os.path.join(self.package_folder, self.cpp_info.bindirs[0], self.conan_data["pyinstaller"]["runinfo"]["entrypoint"])).replace("\\", "\\\\"),
+                                        icon_path = "'{}'".format(os.path.join(self.package_folder, self.cpp_info.resdirs[2], self.conan_data["pyinstaller"]["icon"][str(self.settings.os)])).replace("\\", "\\\\"),
                                         entitlements_file = entitlements_file if self.settings.os == "Macos" else "None")
 
     def package(self):
-        copy(self, "cura_app.py", src = self.source_path, dst = self.package_path.joinpath(self.cpp.package.bindirs[0]))
-        copy(self, "*", src = self.source_path.joinpath("cura"), dst = self.package_path.joinpath(self.cpp.package.libdirs[0]))
-        copy(self, "*", src = self.source_path.joinpath("resources"), dst = self.package_path.joinpath(self.cpp.package.resdirs[0]), excludes="*.po")
-        copy(self, "*", src = self.build_path.joinpath("resources"), dst = self.package_path.joinpath(self.cpp.package.resdirs[0]))
-        copy(self, "*", src = self.source_path.joinpath("plugins"), dst = self.package_path.joinpath(self.cpp.package.resdirs[1]))
-        copy(self, "requirement*.txt", src = self.source_path, dst = self.package_path.joinpath(self.cpp.package.resdirs[-1]))
-        copy(self, "*", src = self.source_path.joinpath("packaging"), dst = self.package_path.joinpath(self.cpp.package.resdirs[2]))
+        copy(self, "cura_app.py", src = self.source_folder, dst = os.path.join(self.package_folder, self.cpp.package.bindirs[0]))
+        copy(self, "*", src = os.path.join(self.source_folder, "cura"), dst = os.path.join(self.package_folder, self.cpp.package.libdirs[0]))
+        copy(self, "*", src = os.path.join(self.source_folder, "resources"), dst = os.path.join(self.package_folder, self.cpp.package.resdirs[0]))
+        copy(self, "*.mo", os.path.join(self.build_folder, "resources"), os.path.join(self.package_folder, "resources"))
+        copy(self, "*", src = os.path.join(self.source_folder, "plugins"), dst = os.path.join(self.package_folder, self.cpp.package.resdirs[1]))
+        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"))
 
     def package_info(self):
         self.user_info.pip_requirements = "requirements.txt"
@@ -463,17 +481,14 @@ echo "CURA_APP_NAME={{ cura_app_name }}" >> ${{ env_prefix }}GITHUB_ENV
         self.user_info.pip_requirements_build = "requirements-dev.txt"
 
         if self.in_local_cache:
-            self.runenv_info.append_path("PYTHONPATH", str(Path(self.cpp_info.lib_paths[0]).parent))
-            self.runenv_info.append_path("PYTHONPATH", self.cpp_info.res_paths[1])  # Add plugins to PYTHONPATH
+            self.runenv_info.append_path("PYTHONPATH", os.path.join(self.package_folder, "site-packages"))
+            self.runenv_info.append_path("PYTHONPATH", os.path.join(self.package_folder, "plugins"))
         else:
             self.runenv_info.append_path("PYTHONPATH", self.source_folder)
             self.runenv_info.append_path("PYTHONPATH", os.path.join(self.source_folder, "plugins"))
 
     def package_id(self):
-        del self.info.settings.os
-        del self.info.settings.compiler
-        del self.info.settings.build_type
-        del self.info.settings.arch
+        self.info.clear()
 
         # The following options shouldn't be used to determine the hash, since these are only used to set the CuraVersion.py
         # which will als be generated by the deploy method during the `conan install cura/5.1.0@_/_`

cura/ApplicationMetadata.py

@@ -14,7 +14,7 @@ DEFAULT_CURA_LATEST_URL = "https://software.ultimaker.com/latest.json"
 # Each release has a fixed SDK version coupled with it. It doesn't make sense to make it configurable because, for
 # example Cura 3.2 with SDK version 6.1 will not work. So the SDK version is hard-coded here and left out of the
 # CuraVersion.py.in template.
-CuraSDKVersion = "8.3.0"
+CuraSDKVersion = "8.4.0"
 
 try:
     from cura.CuraVersion import CuraLatestURL

cura/Arranging/ArrangeObjectsJob.py

@@ -8,17 +8,20 @@ from UM.Logger import Logger
 from UM.Message import Message
 from UM.Scene.SceneNode import SceneNode
 from UM.i18n import i18nCatalog
-from cura.Arranging.Nest2DArrange import arrange
+from cura.Arranging.GridArrange import GridArrange
+from cura.Arranging.Nest2DArrange import Nest2DArrange
 
 i18n_catalog = i18nCatalog("cura")
 
 
 class ArrangeObjectsJob(Job):
-    def __init__(self, nodes: List[SceneNode], fixed_nodes: List[SceneNode], min_offset = 8) -> None:
+    def __init__(self, nodes: List[SceneNode], fixed_nodes: List[SceneNode], min_offset = 8,
+                *, grid_arrange: bool = False) -> None:
         super().__init__()
         self._nodes = nodes
         self._fixed_nodes = fixed_nodes
         self._min_offset = min_offset
+        self._grid_arrange = grid_arrange
 
     def run(self):
         found_solution_for_all = False
@@ -29,10 +32,18 @@ class ArrangeObjectsJob(Job):
                                  title = i18n_catalog.i18nc("@info:title", "Finding Location"))
         status_message.show()
 
+        if self._grid_arrange:
+            arranger = GridArrange(self._nodes, Application.getInstance().getBuildVolume(), self._fixed_nodes)
+        else:
+            arranger = Nest2DArrange(self._nodes, Application.getInstance().getBuildVolume(), self._fixed_nodes,
+                                     factor=1000)
+
+        found_solution_for_all = False
         try:
-            found_solution_for_all = arrange(self._nodes, Application.getInstance().getBuildVolume(), self._fixed_nodes)
+            found_solution_for_all = arranger.arrange()
         except:  # If the thread crashes, the message should still close
-            Logger.logException("e", "Unable to arrange the objects on the buildplate. The arrange algorithm has crashed.")
+            Logger.logException("e",
+                                "Unable to arrange the objects on the buildplate. The arrange algorithm has crashed.")
 
         status_message.hide()
 

cura/Arranging/Arranger.py

@@ -0,0 +1,28 @@
+from typing import List, TYPE_CHECKING, Optional, Tuple, Set
+
+if TYPE_CHECKING:
+    from UM.Operations.GroupedOperation import GroupedOperation
+
+
+class Arranger:
+    def createGroupOperationForArrange(self, *, add_new_nodes_in_scene: bool = False) -> Tuple["GroupedOperation", int]:
+        """
+        Find placement for a set of scene nodes, but don't actually move them just yet.
+        :param add_new_nodes_in_scene: Whether to create new scene nodes before applying the transformations and rotations
+        :return: tuple (found_solution_for_all, node_items)
+            WHERE
+            found_solution_for_all: Whether the algorithm found a place on the buildplate for all the objects
+            node_items: A list of the nodes return by libnest2d, which contain the new positions on the buildplate
+        """
+        raise NotImplementedError
+
+    def arrange(self, *, add_new_nodes_in_scene: bool = False) -> bool:
+        """
+        Find placement for a set of scene nodes, and move them by using a single grouped operation.
+        :param add_new_nodes_in_scene: Whether to create new scene nodes before applying the transformations and rotations
+        :return: found_solution_for_all: Whether the algorithm found a place on the buildplate for all the objects
+        """
+        grouped_operation, not_fit_count = self.createGroupOperationForArrange(
+            add_new_nodes_in_scene=add_new_nodes_in_scene)
+        grouped_operation.push()
+        return not_fit_count == 0

cura/Arranging/GridArrange.py

@@ -0,0 +1,347 @@
+import math
+from typing import List, TYPE_CHECKING, Tuple, Set, Union
+
+if TYPE_CHECKING:
+    from UM.Scene.SceneNode import SceneNode
+    from cura.BuildVolume import BuildVolume
+
+from UM.Application import Application
+from UM.Math.AxisAlignedBox import AxisAlignedBox
+from UM.Math.Polygon import Polygon
+from UM.Math.Vector import Vector
+from UM.Operations.AddSceneNodeOperation import AddSceneNodeOperation
+from UM.Operations.GroupedOperation import GroupedOperation
+from UM.Operations.TranslateOperation import TranslateOperation
+from cura.Arranging.Arranger import Arranger
+
+
+class GridArrange(Arranger):
+    def __init__(self, nodes_to_arrange: List["SceneNode"], build_volume: "BuildVolume", fixed_nodes: List["SceneNode"] = None):
+        if fixed_nodes is None:
+            fixed_nodes = []
+        self._nodes_to_arrange = nodes_to_arrange
+        self._build_volume = build_volume
+        self._build_volume_bounding_box = build_volume.getBoundingBox()
+        self._fixed_nodes = fixed_nodes
+
+        self._margin_x: float = 1
+        self._margin_y: float = 1
+
+        self._grid_width = 0
+        self._grid_height = 0
+        for node in self._nodes_to_arrange:
+            bounding_box = node.getBoundingBox()
+            self._grid_width = max(self._grid_width, bounding_box.width)
+            self._grid_height = max(self._grid_height, bounding_box.depth)
+        self._grid_width += self._margin_x
+        self._grid_height += self._margin_y
+
+        # Round up the grid size to the nearest cm, this assures that new objects will
+        # be placed on integer offsets from each other
+        grid_precision = 10  # 1cm
+        rounded_grid_width = math.ceil(self._grid_width / grid_precision) * grid_precision
+        rounded_grid_height = math.ceil(self._grid_height / grid_precision) * grid_precision
+
+        # The space added by the "grid precision rounding up" of the grid size
+        self._grid_round_margin_x = rounded_grid_width - self._grid_width
+        self._grid_round_margin_y = rounded_grid_height - self._grid_height
+
+        self._grid_width = rounded_grid_width
+        self._grid_height = rounded_grid_height
+
+        self._offset_x = 0
+        self._offset_y = 0
+        self._findOptimalGridOffset()
+
+        coord_initial_leftover_x = self._build_volume_bounding_box.right + 2 * self._grid_width
+        coord_initial_leftover_y = (self._build_volume_bounding_box.back + self._build_volume_bounding_box.front) * 0.5
+        self._initial_leftover_grid_x, self._initial_leftover_grid_y = self._coordSpaceToGridSpace(
+            coord_initial_leftover_x, coord_initial_leftover_y)
+        self._initial_leftover_grid_x = math.floor(self._initial_leftover_grid_x)
+        self._initial_leftover_grid_y = math.floor(self._initial_leftover_grid_y)
+
+        # Find grid indexes that intersect with fixed objects
+        self._fixed_nodes_grid_ids = set()
+        for node in self._fixed_nodes:
+            self._fixed_nodes_grid_ids = self._fixed_nodes_grid_ids.union(
+                self._intersectingGridIdxInclusive(node.getBoundingBox()))
+
+        # grid indexes that are in disallowed area
+        for polygon in self._build_volume.getDisallowedAreas():
+            self._fixed_nodes_grid_ids = self._fixed_nodes_grid_ids.union(self._intersectingGridIdxInclusive(polygon))
+
+        self._build_plate_grid_ids = self._intersectingGridIdxExclusive(self._build_volume_bounding_box)
+
+        # Filter out the corner grid squares if the build plate shape is elliptic
+        if self._build_volume.getShape() == "elliptic":
+            self._build_plate_grid_ids = set(
+                filter(lambda grid_id: self._checkGridUnderDiscSpace(grid_id[0], grid_id[1]),
+                       self._build_plate_grid_ids))
+
+        self._allowed_grid_idx = self._build_plate_grid_ids.difference(self._fixed_nodes_grid_ids)
+
+    def createGroupOperationForArrange(self, *, add_new_nodes_in_scene: bool = False) -> Tuple[GroupedOperation, int]:
+        # Find the sequence in which items are placed
+        coord_build_plate_center_x = self._build_volume_bounding_box.width * 0.5 + self._build_volume_bounding_box.left
+        coord_build_plate_center_y = self._build_volume_bounding_box.depth * 0.5 + self._build_volume_bounding_box.back
+        grid_build_plate_center_x, grid_build_plate_center_y = self._coordSpaceToGridSpace(coord_build_plate_center_x,
+                                                                                           coord_build_plate_center_y)
+
+        sequence: List[Tuple[int, int]] = list(self._allowed_grid_idx)
+        sequence.sort(key=lambda grid_id: (grid_build_plate_center_x - grid_id[0]) ** 2 + (
+                    grid_build_plate_center_y - grid_id[1]) ** 2)
+        scene_root = Application.getInstance().getController().getScene().getRoot()
+        grouped_operation = GroupedOperation()
+
+        for grid_id, node in zip(sequence, self._nodes_to_arrange):
+            if add_new_nodes_in_scene:
+                grouped_operation.addOperation(AddSceneNodeOperation(node, scene_root))
+            grid_x, grid_y = grid_id
+            operation = self._moveNodeOnGrid(node, grid_x, grid_y)
+            grouped_operation.addOperation(operation)
+
+        leftover_nodes = self._nodes_to_arrange[len(sequence):]
+
+        left_over_grid_y = self._initial_leftover_grid_y
+        for node in leftover_nodes:
+            if add_new_nodes_in_scene:
+                grouped_operation.addOperation(AddSceneNodeOperation(node, scene_root))
+            # find the first next grid position that isn't occupied by a fixed node
+            while (self._initial_leftover_grid_x, left_over_grid_y) in self._fixed_nodes_grid_ids:
+                left_over_grid_y = left_over_grid_y - 1
+
+            operation = self._moveNodeOnGrid(node, self._initial_leftover_grid_x, left_over_grid_y)
+            grouped_operation.addOperation(operation)
+            left_over_grid_y = left_over_grid_y - 1
+
+        return grouped_operation, len(leftover_nodes)
+
+    def _findOptimalGridOffset(self):
+        if len(self._fixed_nodes) == 0:
+            self._offset_x = 0
+            self._offset_y = 0
+            return
+
+        if len(self._fixed_nodes) == 1:
+            center_grid_x = 0.5 * self._grid_width + self._build_volume_bounding_box.left
+            center_grid_y = 0.5 * self._grid_height + self._build_volume_bounding_box.back
+
+            bounding_box = self._fixed_nodes[0].getBoundingBox()
+            center_node_x = (bounding_box.left + bounding_box.right) * 0.5
+            center_node_y = (bounding_box.back + bounding_box.front) * 0.5
+
+            self._offset_x = center_node_x - center_grid_x
+            self._offset_y = center_node_y - center_grid_y
+
+            return
+
+        # If there are multiple fixed nodes, an optimal solution is not always possible
+        # We will try to find an offset that minimizes the number of grid intersections
+        # with fixed nodes. The algorithm below achieves this by utilizing a scanline
+        # algorithm. In this algorithm each axis is solved separately as offsetting
+        # is completely independent in each axis. The comments explaining the algorithm
+        # below are for the x-axis, but the same applies for the y-axis.
+        #
+        # Each node either occupies ceil((node.right - node.right) / grid_width) or
+        # ceil((node.right - node.right) / grid_width) + 1 grid squares. We will call
+        # these the node's "footprint".
+        #
+        #                      ┌────────────────┐
+        #   minimum foot-print │      NODE      │
+        #                      └────────────────┘
+        # │    grid 1   │    grid 2    │    grid 3    │    grid 4    |    grid 5    |
+        #                             ┌────────────────┐
+        #          maximum foot-print │      NODE      │
+        #                             └────────────────┘
+        #
+        # The algorithm will find the grid offset such that the number of nodes with
+        # a _minimal_ footprint is _maximized_.
+
+        # The scanline algorithm works as follows, we create events for both end points
+        # of each node's footprint. The event have two properties,
+        # - the coordinate: the amount the endpoint can move to the
+        #      left before it crosses a grid line
+        # - the change: either +1 or -1, indicating whether crossing the grid line
+        #      would result in a minimal footprint node becoming a maximal footprint
+        class Event:
+            def __init__(self, coord: float, change: float):
+                self.coord = coord
+                self.change = change
+
+        # create events for both the horizontal and vertical axis
+        events_horizontal: List[Event] = []
+        events_vertical: List[Event] = []
+
+        for node in self._fixed_nodes:
+            bounding_box = node.getBoundingBox()
+
+            left = bounding_box.left - self._build_volume_bounding_box.left
+            right = bounding_box.right - self._build_volume_bounding_box.left
+            back = bounding_box.back - self._build_volume_bounding_box.back
+            front = bounding_box.front - self._build_volume_bounding_box.back
+
+            value_left = math.ceil(left / self._grid_width) * self._grid_width - left
+            value_right = math.ceil(right / self._grid_width) * self._grid_width - right
+            value_back = math.ceil(back / self._grid_height) * self._grid_height - back
+            value_front = math.ceil(front / self._grid_height) * self._grid_height - front
+
+            # give nodes a weight according to their size. This
+            # weight is heuristically chosen to be proportional to
+            # the number of grid squares the node-boundary occupies
+            weight = bounding_box.width + bounding_box.depth
+
+            events_horizontal.append(Event(value_left, weight))
+            events_horizontal.append(Event(value_right, -weight))
+            events_vertical.append(Event(value_back, weight))
+            events_vertical.append(Event(value_front, -weight))
+
+        events_horizontal.sort(key=lambda event: event.coord)
+        events_vertical.sort(key=lambda event: event.coord)
+
+        def findOptimalShiftAxis(events: List[Event], interval: float) -> float:
+            # executing the actual scanline algorithm
+            # iteratively go through events (left to right) and keep track of the
+            # current footprint. The optimal location is the one with the minimal
+            # footprint. If there are multiple locations with the same minimal
+            # footprint, the optimal location is the one with the largest range
+            # between the left and right endpoint of the footprint.
+            prev_offset = events[-1].coord - interval
+            current_minimal_footprint_count = 0
+
+            best_minimal_footprint_count = float('inf')
+            best_offset_span = float('-inf')
+            best_offset = 0.0
+
+            for event in events:
+                offset_span = event.coord - prev_offset
+
+                if current_minimal_footprint_count < best_minimal_footprint_count or (
+                        current_minimal_footprint_count == best_minimal_footprint_count and offset_span > best_offset_span):
+                    best_minimal_footprint_count = current_minimal_footprint_count
+                    best_offset_span = offset_span
+                    best_offset = event.coord
+
+                current_minimal_footprint_count += event.change
+                prev_offset = event.coord
+
+            return best_offset - best_offset_span * 0.5
+
+        center_grid_x = 0.5 * self._grid_width
+        center_grid_y = 0.5 * self._grid_height
+
+        optimal_center_x = self._grid_width - findOptimalShiftAxis(events_horizontal, self._grid_width)
+        optimal_center_y = self._grid_height - findOptimalShiftAxis(events_vertical, self._grid_height)
+
+        self._offset_x = optimal_center_x - center_grid_x
+        self._offset_y = optimal_center_y - center_grid_y
+
+    def _moveNodeOnGrid(self, node: "SceneNode", grid_x: int, grid_y: int) -> "Operation.Operation":
+        coord_grid_x, coord_grid_y = self._gridSpaceToCoordSpace(grid_x, grid_y)
+        center_grid_x = coord_grid_x + (0.5 * self._grid_width)
+        center_grid_y = coord_grid_y + (0.5 * self._grid_height)
+
+        bounding_box = node.getBoundingBox()
+        center_node_x = (bounding_box.left + bounding_box.right) * 0.5
+        center_node_y = (bounding_box.back + bounding_box.front) * 0.5
+
+        delta_x = center_grid_x - center_node_x
+        delta_y = center_grid_y - center_node_y
+
+        return TranslateOperation(node, Vector(delta_x, 0, delta_y))
+
+    def _getGridCornerPoints(
+            self,
+            bounds: Union[AxisAlignedBox, Polygon],
+            *,
+            margin_x: float = 0.0,
+            margin_y: float = 0.0
+    ) -> Tuple[float, float, float, float]:
+        if isinstance(bounds, AxisAlignedBox):
+            coord_x1 = bounds.left - margin_x
+            coord_x2 = bounds.right + margin_x
+            coord_y1 = bounds.back - margin_y
+            coord_y2 = bounds.front + margin_y
+        elif isinstance(bounds, Polygon):
+            coord_x1 = float('inf')
+            coord_y1 = float('inf')
+            coord_x2 = float('-inf')
+            coord_y2 = float('-inf')
+            for x, y in bounds.getPoints():
+                coord_x1 = min(coord_x1, x)
+                coord_y1 = min(coord_y1, y)
+                coord_x2 = max(coord_x2, x)
+                coord_y2 = max(coord_y2, y)
+        else:
+            raise TypeError("bounds must be either an AxisAlignedBox or a Polygon")
+
+        coord_x1 -= margin_x
+        coord_x2 += margin_x
+        coord_y1 -= margin_y
+        coord_y2 += margin_y
+
+        grid_x1, grid_y1 = self._coordSpaceToGridSpace(coord_x1, coord_y1)
+        grid_x2, grid_y2 = self._coordSpaceToGridSpace(coord_x2, coord_y2)
+        return grid_x1, grid_y1, grid_x2, grid_y2
+
+    def _intersectingGridIdxInclusive(self, bounds: Union[AxisAlignedBox, Polygon]) -> Set[Tuple[int, int]]:
+        grid_x1, grid_y1, grid_x2, grid_y2 = self._getGridCornerPoints(
+            bounds,
+            margin_x=-(self._margin_x + self._grid_round_margin_x) * 0.5,
+            margin_y=-(self._margin_y + self._grid_round_margin_y) * 0.5,
+        )
+        grid_idx = set()
+        for grid_x in range(math.floor(grid_x1), math.ceil(grid_x2)):
+            for grid_y in range(math.floor(grid_y1), math.ceil(grid_y2)):
+                grid_idx.add((grid_x, grid_y))
+        return grid_idx
+
+    def _intersectingGridIdxExclusive(self, bounds: Union[AxisAlignedBox, Polygon]) -> Set[Tuple[int, int]]:
+        grid_x1, grid_y1, grid_x2, grid_y2 = self._getGridCornerPoints(
+            bounds,
+            margin_x=(self._margin_x + self._grid_round_margin_x) * 0.5,
+            margin_y=(self._margin_y + self._grid_round_margin_y) * 0.5,
+        )
+        grid_idx = set()
+        for grid_x in range(math.ceil(grid_x1), math.floor(grid_x2)):
+            for grid_y in range(math.ceil(grid_y1), math.floor(grid_y2)):
+                grid_idx.add((grid_x, grid_y))
+        return grid_idx
+
+    def _gridSpaceToCoordSpace(self, x: float, y: float) -> Tuple[float, float]:
+        grid_x = x * self._grid_width + self._build_volume_bounding_box.left + self._offset_x
+        grid_y = y * self._grid_height + self._build_volume_bounding_box.back + self._offset_y
+        return grid_x, grid_y
+
+    def _coordSpaceToGridSpace(self, grid_x: float, grid_y: float) -> Tuple[float, float]:
+        coord_x = (grid_x - self._build_volume_bounding_box.left - self._offset_x) / self._grid_width
+        coord_y = (grid_y - self._build_volume_bounding_box.back - self._offset_y) / self._grid_height
+        return coord_x, coord_y
+
+    def _checkGridUnderDiscSpace(self, grid_x: int, grid_y: int) -> bool:
+        left, back = self._gridSpaceToCoordSpace(grid_x, grid_y)
+        right, front = self._gridSpaceToCoordSpace(grid_x + 1, grid_y + 1)
+        corners = [(left, back), (right, back), (right, front), (left, front)]
+        return all([self._checkPointUnderDiscSpace(x, y) for x, y in corners])
+
+    def _checkPointUnderDiscSpace(self, x: float, y: float) -> bool:
+        disc_x, disc_y = self._coordSpaceToDiscSpace(x, y)
+        distance_to_center_squared = disc_x ** 2 + disc_y ** 2
+        return distance_to_center_squared <= 1.0
+
+    def _coordSpaceToDiscSpace(self, x: float, y: float) -> Tuple[float, float]:
+        # Transform coordinate system to
+        #
+        #       coord_build_plate_left = -1
+        #       |               coord_build_plate_right = 1
+        #       v     (0,1)     v
+        #       ┌───────┬───────┐  < coord_build_plate_back = -1
+        #       │       │       │
+        #       │       │(0,0)  │
+        # (-1,0)├───────o───────┤(1,0)
+        #       │       │       │
+        #       │       │       │
+        #       └───────┴───────┘  < coord_build_plate_front = +1
+        #             (0,-1)
+        disc_x = ((x - self._build_volume_bounding_box.left) / self._build_volume_bounding_box.width) * 2.0 - 1.0
+        disc_y = ((y - self._build_volume_bounding_box.back) / self._build_volume_bounding_box.depth) * 2.0 - 1.0
+        return disc_x, disc_y

cura/Arranging/Nest2DArrange.py

@@ -15,148 +15,137 @@ from UM.Operations.AddSceneNodeOperation import AddSceneNodeOperation
 from UM.Operations.GroupedOperation import GroupedOperation
 from UM.Operations.RotateOperation import RotateOperation
 from UM.Operations.TranslateOperation import TranslateOperation
-
+from cura.Arranging.Arranger import Arranger
 
 if TYPE_CHECKING:
     from UM.Scene.SceneNode import SceneNode
     from cura.BuildVolume import BuildVolume
 
 
-def findNodePlacement(nodes_to_arrange: List["SceneNode"], build_volume: "BuildVolume", fixed_nodes: Optional[List["SceneNode"]] = None, factor = 10000) -> Tuple[bool, List[Item]]:
-    """
-    Find placement for a set of scene nodes, but don't actually move them just yet.
-    :param nodes_to_arrange: The list of nodes that need to be moved.
-    :param build_volume: The build volume that we want to place the nodes in. It gets size & disallowed areas from this.
-    :param fixed_nodes: List of nods that should not be moved, but should be used when deciding where the others nodes
-                        are placed.
-    :param factor: The library that we use is int based. This factor defines how accurate we want it to be.
+class Nest2DArrange(Arranger):
+    def __init__(self,
+                 nodes_to_arrange: List["SceneNode"],
+                 build_volume: "BuildVolume",
+                 fixed_nodes: Optional[List["SceneNode"]] = None,
+                 *,
+                 factor: int = 10000,
+                 lock_rotation: bool = False):
+        """
+        :param nodes_to_arrange: The list of nodes that need to be moved.
+        :param build_volume: The build volume that we want to place the nodes in. It gets size & disallowed areas from this.
+        :param fixed_nodes: List of nods that should not be moved, but should be used when deciding where the others nodes
+                            are placed.
+        :param factor: The library that we use is int based. This factor defines how accuracte we want it to be.
+        :param lock_rotation: If set to true the orientation of the object will remain the same
+        """
+        super().__init__()
+        self._nodes_to_arrange = nodes_to_arrange
+        self._build_volume = build_volume
+        self._fixed_nodes = fixed_nodes
+        self._factor = factor
+        self._lock_rotation = lock_rotation
 
-    :return: tuple (found_solution_for_all, node_items)
-        WHERE
-        found_solution_for_all: Whether the algorithm found a place on the buildplate for all the objects
-        node_items: A list of the nodes return by libnest2d, which contain the new positions on the buildplate
-    """
-    spacing = int(1.5 * factor)  # 1.5mm spacing.
+    def findNodePlacement(self) -> Tuple[bool, List[Item]]:
+        spacing = int(1.5 * self._factor)  # 1.5mm spacing.
 
-    machine_width = build_volume.getWidth()
-    machine_depth = build_volume.getDepth()
-    build_plate_bounding_box = Box(int(machine_width * factor), int(machine_depth * factor))
+        machine_width = self._build_volume.getWidth()
+        machine_depth = self._build_volume.getDepth()
+        build_plate_bounding_box = Box(int(machine_width * self._factor), int(machine_depth * self._factor))
 
-    if fixed_nodes is None:
-        fixed_nodes = []
+        if self._fixed_nodes is None:
+            self._fixed_nodes = []
 
-    # Add all the items we want to arrange
-    node_items = []
-    for node in nodes_to_arrange:
-        hull_polygon = node.callDecoration("getConvexHull")
-        if not hull_polygon or hull_polygon.getPoints is None:
-            Logger.log("w", "Object {} cannot be arranged because it has no convex hull.".format(node.getName()))
-            continue
-        converted_points = []
-        for point in hull_polygon.getPoints():
-            converted_points.append(Point(int(point[0] * factor), int(point[1] * factor)))
-        item = Item(converted_points)
-        node_items.append(item)
-
-    # Use a tiny margin for the build_plate_polygon (the nesting doesn't like overlapping disallowed areas)
-    half_machine_width = 0.5 * machine_width - 1
-    half_machine_depth = 0.5 * machine_depth - 1
-    build_plate_polygon = Polygon(numpy.array([
-        [half_machine_width, -half_machine_depth],
-        [-half_machine_width, -half_machine_depth],
-        [-half_machine_width, half_machine_depth],
-        [half_machine_width, half_machine_depth]
-    ], numpy.float32))
-
-    disallowed_areas = build_volume.getDisallowedAreas()
-    num_disallowed_areas_added = 0
-    for area in disallowed_areas:
-        converted_points = []
-
-        # Clip the disallowed areas so that they don't overlap the bounding box (The arranger chokes otherwise)
-        clipped_area = area.intersectionConvexHulls(build_plate_polygon)
-
-        if clipped_area.getPoints() is not None and len(clipped_area.getPoints()) > 2:  # numpy array has to be explicitly checked against None
-            for point in clipped_area.getPoints():
-                converted_points.append(Point(int(point[0] * factor), int(point[1] * factor)))
-
-            disallowed_area = Item(converted_points)
-            disallowed_area.markAsDisallowedAreaInBin(0)
-            node_items.append(disallowed_area)
-            num_disallowed_areas_added += 1
-
-    for node in fixed_nodes:
-        converted_points = []
-        hull_polygon = node.callDecoration("getConvexHull")
-
-        if hull_polygon is not None and hull_polygon.getPoints() is not None and len(hull_polygon.getPoints()) > 2:  # numpy array has to be explicitly checked against None
+        # Add all the items we want to arrange
+        node_items = []
+        for node in self._nodes_to_arrange:
+            hull_polygon = node.callDecoration("getConvexHull")
+            if not hull_polygon or hull_polygon.getPoints is None:
+                Logger.log("w", "Object {} cannot be arranged because it has no convex hull.".format(node.getName()))
+                continue
+            converted_points = []
             for point in hull_polygon.getPoints():
-                converted_points.append(Point(int(point[0] * factor), int(point[1] * factor)))
+                converted_points.append(Point(int(point[0] * self._factor), int(point[1] * self._factor)))
             item = Item(converted_points)
-            item.markAsFixedInBin(0)
             node_items.append(item)
-            num_disallowed_areas_added += 1
 
-    config = NfpConfig()
-    config.accuracy = 1.0
+        # Use a tiny margin for the build_plate_polygon (the nesting doesn't like overlapping disallowed areas)
+        half_machine_width = 0.5 * machine_width - 1
+        half_machine_depth = 0.5 * machine_depth - 1
+        build_plate_polygon = Polygon(numpy.array([
+            [half_machine_width, -half_machine_depth],
+            [-half_machine_width, -half_machine_depth],
+            [-half_machine_width, half_machine_depth],
+            [half_machine_width, half_machine_depth]
+        ], numpy.float32))
 
-    num_bins = nest(node_items, build_plate_bounding_box, spacing, config)
+        disallowed_areas = self._build_volume.getDisallowedAreas()
+        num_disallowed_areas_added = 0
+        for area in disallowed_areas:
+            converted_points = []
 
-    # Strip the fixed items (previously placed) and the disallowed areas from the results again.
-    node_items = list(filter(lambda item: not item.isFixed(), node_items))
+            # Clip the disallowed areas so that they don't overlap the bounding box (The arranger chokes otherwise)
+            clipped_area = area.intersectionConvexHulls(build_plate_polygon)
 
-    found_solution_for_all = num_bins == 1
+            if clipped_area.getPoints() is not None and len(
+                    clipped_area.getPoints()) > 2:  # numpy array has to be explicitly checked against None
+                for point in clipped_area.getPoints():
+                    converted_points.append(Point(int(point[0] * self._factor), int(point[1] * self._factor)))
 
-    return found_solution_for_all, node_items
+                disallowed_area = Item(converted_points)
+                disallowed_area.markAsDisallowedAreaInBin(0)
+                node_items.append(disallowed_area)
+                num_disallowed_areas_added += 1
 
+        for node in self._fixed_nodes:
+            converted_points = []
+            hull_polygon = node.callDecoration("getConvexHull")
 
-def createGroupOperationForArrange(nodes_to_arrange: List["SceneNode"],
-                                   build_volume: "BuildVolume",
-                                   fixed_nodes: Optional[List["SceneNode"]] = None,
-                                   factor = 10000,
-                                   add_new_nodes_in_scene: bool = False)  -> Tuple[GroupedOperation, int]:
-    scene_root = Application.getInstance().getController().getScene().getRoot()
-    found_solution_for_all, node_items = findNodePlacement(nodes_to_arrange, build_volume, fixed_nodes, factor)
+            if hull_polygon is not None and hull_polygon.getPoints() is not None and len(
+                    hull_polygon.getPoints()) > 2:  # numpy array has to be explicitly checked against None
+                for point in hull_polygon.getPoints():
+                    converted_points.append(Point(int(point[0] * self._factor), int(point[1] * self._factor)))
+                item = Item(converted_points)
+                item.markAsFixedInBin(0)
+                node_items.append(item)
+                num_disallowed_areas_added += 1
 
-    not_fit_count = 0
-    grouped_operation = GroupedOperation()
-    for node, node_item in zip(nodes_to_arrange, node_items):
-        if add_new_nodes_in_scene:
-            grouped_operation.addOperation(AddSceneNodeOperation(node, scene_root))
+        config = NfpConfig()
+        config.accuracy = 1.0
+        config.alignment = NfpConfig.Alignment.DONT_ALIGN
+        if self._lock_rotation:
+            config.rotations = [0.0]
 
-        if node_item.binId() == 0:
-            # We found a spot for it
-            rotation_matrix = Matrix()
-            rotation_matrix.setByRotationAxis(node_item.rotation(), Vector(0, -1, 0))
-            grouped_operation.addOperation(RotateOperation(node, Quaternion.fromMatrix(rotation_matrix)))
-            grouped_operation.addOperation(TranslateOperation(node, Vector(node_item.translation().x() / factor, 0,
-                                                                           node_item.translation().y() / factor)))
-        else:
-            # We didn't find a spot
-            grouped_operation.addOperation(
-                TranslateOperation(node, Vector(200, node.getWorldPosition().y, -not_fit_count * 20), set_position = True))
-            not_fit_count += 1
+        num_bins = nest(node_items, build_plate_bounding_box, spacing, config)
 
-    return grouped_operation, not_fit_count
+        # Strip the fixed items (previously placed) and the disallowed areas from the results again.
+        node_items = list(filter(lambda item: not item.isFixed(), node_items))
 
+        found_solution_for_all = num_bins == 1
 
-def arrange(nodes_to_arrange: List["SceneNode"],
-            build_volume: "BuildVolume",
-            fixed_nodes: Optional[List["SceneNode"]] = None,
-            factor = 10000,
-            add_new_nodes_in_scene: bool = False) -> bool:
-    """
-    Find placement for a set of scene nodes, and move them by using a single grouped operation.
-    :param nodes_to_arrange: The list of nodes that need to be moved.
-    :param build_volume: The build volume that we want to place the nodes in. It gets size & disallowed areas from this.
-    :param fixed_nodes: List of nods that should not be moved, but should be used when deciding where the others nodes
-                        are placed.
-    :param factor: The library that we use is int based. This factor defines how accuracte we want it to be.
-    :param add_new_nodes_in_scene: Whether to create new scene nodes before applying the transformations and rotations
+        return found_solution_for_all, node_items
 
-    :return: found_solution_for_all: Whether the algorithm found a place on the buildplate for all the objects
-    """
+    def createGroupOperationForArrange(self, *, add_new_nodes_in_scene: bool = False) -> Tuple[GroupedOperation, int]:
+        scene_root = Application.getInstance().getController().getScene().getRoot()
+        found_solution_for_all, node_items = self.findNodePlacement()
 
-    grouped_operation, not_fit_count = createGroupOperationForArrange(nodes_to_arrange, build_volume, fixed_nodes, factor, add_new_nodes_in_scene)
-    grouped_operation.push()
-    return not_fit_count == 0
+        not_fit_count = 0
+        grouped_operation = GroupedOperation()
+        for node, node_item in zip(self._nodes_to_arrange, node_items):
+            if add_new_nodes_in_scene:
+                grouped_operation.addOperation(AddSceneNodeOperation(node, scene_root))
+
+            if node_item.binId() == 0:
+                # We found a spot for it
+                rotation_matrix = Matrix()
+                rotation_matrix.setByRotationAxis(node_item.rotation(), Vector(0, -1, 0))
+                grouped_operation.addOperation(RotateOperation(node, Quaternion.fromMatrix(rotation_matrix)))
+                grouped_operation.addOperation(
+                    TranslateOperation(node, Vector(node_item.translation().x() / self._factor, 0,
+                                                    node_item.translation().y() / self._factor)))
+            else:
+                # We didn't find a spot
+                grouped_operation.addOperation(
+                    TranslateOperation(node, Vector(200, node.getWorldPosition().y, -not_fit_count * 20), set_position = True))
+                not_fit_count += 1
+
+        return grouped_operation, not_fit_count

cura/BackendPlugin.py

@@ -0,0 +1,140 @@
+# Copyright (c) 2023 Ultimaker B.V.
+# Cura is released under the terms of the LGPLv3 or higher.
+import socket
+import os
+import subprocess
+from typing import Optional, List
+
+from UM.Logger import Logger
+from UM.Message import Message
+from UM.Settings.AdditionalSettingDefinitionAppender import AdditionalSettingDefinitionsAppender
+from UM.PluginObject import PluginObject
+from UM.i18n import i18nCatalog
+from UM.Platform import Platform
+from UM.Resources import Resources
+
+
+class BackendPlugin(AdditionalSettingDefinitionsAppender, PluginObject):
+    catalog = i18nCatalog("cura")
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.__port: int = 0
+        self._plugin_address: str = "127.0.0.1"
+        self._plugin_command: Optional[List[str]] = None
+        self._process = None
+        self._is_running = False
+        self._supported_slots: List[int] = []
+        self._use_plugin = True
+
+    def usePlugin(self) -> bool:
+        return self._use_plugin
+
+    def getSupportedSlots(self) -> List[int]:
+        return self._supported_slots
+
+    def isRunning(self):
+        return self._is_running
+
+    def setPort(self, port: int) -> None:
+        self.__port = port
+
+    def getPort(self) -> int:
+        return self.__port
+
+    def getAddress(self) -> str:
+        return self._plugin_address
+
+    def setAvailablePort(self) -> None:
+        """
+        Sets the port to a random available port.
+        """
+        sock = socket.socket()
+        sock.bind((self.getAddress(), 0))
+        port = sock.getsockname()[1]
+        self.setPort(port)
+
+    def _validatePluginCommand(self) -> list[str]:
+        """
+        Validate the plugin command and add the port parameter if it is missing.
+
+        :return: A list of strings containing the validated plugin command.
+        """
+        if not self._plugin_command or "--port" in self._plugin_command:
+            return self._plugin_command or []
+
+        return self._plugin_command + ["--address", self.getAddress(), "--port", str(self.__port)]
+
+    def start(self) -> bool:
+        """
+        Starts the backend_plugin process.
+
+        :return: True if the plugin process started successfully, False otherwise.
+        """
+        if not self.usePlugin():
+            return False
+        Logger.info(f"Starting backend_plugin [{self._plugin_id}] with command: {self._validatePluginCommand()}")
+        plugin_log_path = os.path.join(Resources.getDataStoragePath(), f"{self.getPluginId()}.log")
+        if os.path.exists(plugin_log_path):
+            try:
+                os.remove(plugin_log_path)
+            except:
+                pass  # removing is only done such that it doesn't grow out of proportions, if it fails once or twice that is okay
+        Logger.info(f"Logging plugin output to: {plugin_log_path}")
+        try:
+            # STDIN needs to be None because we provide no input, but communicate via a local socket instead.
+            # The NUL device sometimes doesn't exist on some computers.
+            with open(plugin_log_path, 'a') as f:
+                popen_kwargs = {
+                    "stdin": None,
+                    "stdout": f,  # Redirect output to file
+                    "stderr": subprocess.STDOUT,  # Combine stderr and stdout
+                }
+                if Platform.isWindows():
+                    popen_kwargs["creationflags"] = subprocess.CREATE_NO_WINDOW
+                self._process = subprocess.Popen(self._validatePluginCommand(), **popen_kwargs)
+            self._is_running = True
+            return True
+        except PermissionError:
+            Logger.log("e", f"Couldn't start EnginePlugin: {self._plugin_id} No permission to execute process.")
+            self._showMessage(self.catalog.i18nc("@info:plugin_failed",
+                                                 f"Couldn't start EnginePlugin: {self._plugin_id}\nNo permission to execute process."),
+                              message_type = Message.MessageType.ERROR)
+        except FileNotFoundError:
+            Logger.logException("e", f"Unable to find local EnginePlugin server executable for: {self._plugin_id}")
+            self._showMessage(self.catalog.i18nc("@info:plugin_failed",
+                                                 f"Unable to find local EnginePlugin server executable for: {self._plugin_id}"),
+                              message_type = Message.MessageType.ERROR)
+        except BlockingIOError:
+            Logger.logException("e", f"Couldn't start EnginePlugin: {self._plugin_id} Resource is temporarily unavailable")
+            self._showMessage(self.catalog.i18nc("@info:plugin_failed",
+                                                 f"Couldn't start EnginePlugin: {self._plugin_id}\nResource is temporarily unavailable"),
+                              message_type = Message.MessageType.ERROR)
+        except OSError as e:
+            Logger.logException("e", f"Couldn't start EnginePlugin {self._plugin_id} Operating system is blocking it (antivirus?)")
+            self._showMessage(self.catalog.i18nc("@info:plugin_failed",
+                                                 f"Couldn't start EnginePlugin: {self._plugin_id}\nOperating system is blocking it (antivirus?)"),
+                              message_type = Message.MessageType.ERROR)
+        return False
+
+    def stop(self) -> bool:
+        if not self._process:
+            self._is_running = False
+            return True  # Nothing to stop
+
+        try:
+            self._process.terminate()
+            return_code = self._process.wait()
+            self._is_running = False
+            Logger.log("d", f"EnginePlugin: {self._plugin_id} was killed. Received return code {return_code}")
+            return True
+        except PermissionError:
+            Logger.log("e", f"Unable to kill running EnginePlugin: {self._plugin_id} Access is denied.")
+            self._showMessage(self.catalog.i18nc("@info:plugin_failed",
+                                                 f"Unable to kill running EnginePlugin: {self._plugin_id}\nAccess is denied."),
+                              message_type = Message.MessageType.ERROR)
+            return False
+
+    def _showMessage(self, message: str, message_type: Message.MessageType = Message.MessageType.ERROR) -> None:
+        Message(message, title=self.catalog.i18nc("@info:title", "EnginePlugin"), message_type = message_type).show()
+

cura/BuildVolume.py

@@ -203,6 +203,9 @@ class BuildVolume(SceneNode):
         if shape:
             self._shape = shape
 
+    def getShape(self) -> str:
+        return self._shape
+
     def getDiagonalSize(self) -> float:
         """Get the length of the 3D diagonal through the build volume.
 
@@ -648,11 +651,13 @@ class BuildVolume(SceneNode):
             self._width = self._global_container_stack.getProperty("machine_width", "value")
             machine_height = self._global_container_stack.getProperty("machine_height", "value")
             if self._global_container_stack.getProperty("print_sequence", "value") == "one_at_a_time" and len(self._scene_objects) > 1:
-                self._height = min(self._global_container_stack.getProperty("gantry_height", "value") * self._scale_vector.z, machine_height)
-                if self._height < (machine_height * self._scale_vector.z):
+                new_height = min(self._global_container_stack.getProperty("gantry_height", "value") * self._scale_vector.z, machine_height)
+
+                if self._height > new_height:
                     self._build_volume_message.show()
-                else:
+                elif self._height < new_height:
                     self._build_volume_message.hide()
+                self._height = new_height
             else:
                 self._height = self._global_container_stack.getProperty("machine_height", "value")
                 self._build_volume_message.hide()
@@ -690,11 +695,15 @@ class BuildVolume(SceneNode):
             if setting_key == "print_sequence":
                 machine_height = self._global_container_stack.getProperty("machine_height", "value")
                 if self._application.getGlobalContainerStack().getProperty("print_sequence", "value") == "one_at_a_time" and len(self._scene_objects) > 1:
-                    self._height = min(self._global_container_stack.getProperty("gantry_height", "value") * self._scale_vector.z, machine_height)
-                    if self._height < (machine_height * self._scale_vector.z):
+                    new_height = min(
+                        self._global_container_stack.getProperty("gantry_height", "value") * self._scale_vector.z,
+                        machine_height)
+
+                    if self._height > new_height:
                         self._build_volume_message.show()
-                    else:
+                    elif self._height < new_height:
                         self._build_volume_message.hide()
+                    self._height = new_height
                 else:
                     self._height = self._global_container_stack.getProperty("machine_height", "value") * self._scale_vector.z
                     self._build_volume_message.hide()

cura/CrashHandler.py

@@ -22,7 +22,7 @@ except ImportError:
 
 from PyQt6.QtCore import QT_VERSION_STR, PYQT_VERSION_STR, QUrl
 from PyQt6.QtWidgets import QDialog, QDialogButtonBox, QVBoxLayout, QLabel, QTextEdit, QGroupBox, QCheckBox, QPushButton
-from PyQt6.QtGui import QDesktopServices
+from PyQt6.QtGui import QDesktopServices, QTextCursor
 
 from UM.Application import Application
 from UM.Logger import Logger
@@ -309,7 +309,7 @@ class CrashHandler:
         trace = "".join(trace_list)
         text_area.setText(trace)
         text_area.setReadOnly(True)
-
+        text_area.moveCursor(QTextCursor.MoveOperation.End)  # Move cursor to end, so we see last bit of the exception
         layout.addWidget(text_area)
         group.setLayout(layout)
 
@@ -400,7 +400,7 @@ class CrashHandler:
 
         text_area.setText(logdata)
         text_area.setReadOnly(True)
-
+        text_area.moveCursor(QTextCursor.MoveOperation.End)  # Move cursor to end, so we see last bit of the log
         layout.addWidget(text_area)
         group.setLayout(layout)
 

cura/CuraActions.py

@@ -1,15 +1,18 @@
-# Copyright (c) 2018 Ultimaker B.V.
+# Copyright (c) 2023 UltiMaker
 # Cura is released under the terms of the LGPLv3 or higher.
 
-from PyQt6.QtCore import QObject, QUrl
-from PyQt6.QtGui import QDesktopServices
 from typing import List, cast
 
+from PyQt6.QtCore import QObject, QUrl, QMimeData
+from PyQt6.QtGui import QDesktopServices
+from PyQt6.QtWidgets import QApplication
+
 from UM.Event import CallFunctionEvent
 from UM.FlameProfiler import pyqtSlot
 from UM.Math.Vector import Vector
 from UM.Scene.Selection import Selection
 from UM.Scene.Iterator.BreadthFirstIterator import BreadthFirstIterator
+from UM.Scene.Iterator.DepthFirstIterator import DepthFirstIterator
 from UM.Operations.GroupedOperation import GroupedOperation
 from UM.Operations.RemoveSceneNodeOperation import RemoveSceneNodeOperation
 from UM.Operations.TranslateOperation import TranslateOperation
@@ -20,6 +23,10 @@ from cura.MultiplyObjectsJob import MultiplyObjectsJob
 from cura.Settings.SetObjectExtruderOperation import SetObjectExtruderOperation
 from cura.Settings.ExtruderManager import ExtruderManager
 
+from cura.Arranging.GridArrange import GridArrange
+from cura.Arranging.Nest2DArrange import Nest2DArrange
+
+
 from cura.Operations.SetBuildPlateNumberOperation import SetBuildPlateNumberOperation
 
 from UM.Logger import Logger
@@ -78,16 +85,25 @@ class CuraActions(QObject):
             center_operation = TranslateOperation(current_node, Vector(0, center_y, 0), set_position = True)
             operation.addOperation(center_operation)
         operation.push()
-
     @pyqtSlot(int)
     def multiplySelection(self, count: int) -> None:
         """Multiply all objects in the selection
+        :param count: The number of times to multiply the selection.
+        """
+        min_offset = cura.CuraApplication.CuraApplication.getInstance().getBuildVolume().getEdgeDisallowedSize() + 2  # Allow for some rounding errors
+        job = MultiplyObjectsJob(Selection.getAllSelectedObjects(), count, min_offset = max(min_offset, 8))
+        job.start()
+
+    @pyqtSlot(int)
+    def multiplySelectionToGrid(self, count: int) -> None:
+        """Multiply all objects in the selection
 
         :param count: The number of times to multiply the selection.
         """
 
         min_offset = cura.CuraApplication.CuraApplication.getInstance().getBuildVolume().getEdgeDisallowedSize() + 2  # Allow for some rounding errors
-        job = MultiplyObjectsJob(Selection.getAllSelectedObjects(), count, min_offset = max(min_offset, 8))
+        job = MultiplyObjectsJob(Selection.getAllSelectedObjects(), count, min_offset=max(min_offset, 8),
+                                 grid_arrange=True)
         job.start()
 
     @pyqtSlot()
@@ -181,5 +197,60 @@ class CuraActions(QObject):
 
         Selection.clear()
 
+    @pyqtSlot()
+    def cut(self) -> None:
+        self.copy()
+        self.deleteSelection()
+
+    @pyqtSlot()
+    def copy(self) -> None:
+        mesh_writer = cura.CuraApplication.CuraApplication.getInstance().getMeshFileHandler().getWriter("3MFWriter")
+        if not mesh_writer:
+            Logger.log("e", "No 3MF writer found, unable to copy.")
+            return
+
+        # Get the selected nodes
+        selected_objects = Selection.getAllSelectedObjects()
+        # Serialize the nodes to a string
+        scene_string = mesh_writer.sceneNodesToString(selected_objects)
+        # Put the string on the clipboard
+        QApplication.clipboard().setText(scene_string)
+
+    @pyqtSlot()
+    def paste(self) -> None:
+        application = cura.CuraApplication.CuraApplication.getInstance()
+        mesh_reader = application.getMeshFileHandler().getReaderForFile(".3mf")
+        if not mesh_reader:
+            Logger.log("e", "No 3MF reader found, unable to paste.")
+            return
+
+        # Parse the scene from the clipboard
+        scene_string = QApplication.clipboard().text()
+
+        nodes = mesh_reader.stringToSceneNodes(scene_string)
+
+        if not nodes:
+            # Nothing to paste
+            return
+
+        # Find all fixed nodes, these are the nodes that should be avoided when arranging
+        fixed_nodes = []
+        root = application.getController().getScene().getRoot()
+        for node in DepthFirstIterator(root):
+            # Only count sliceable objects
+            if node.callDecoration("isSliceable"):
+                fixed_nodes.append(node)
+        # Add the new nodes to the scene, and arrange them
+
+        arranger = GridArrange(nodes, application.getBuildVolume(), fixed_nodes)
+        group_operation, not_fit_count = arranger.createGroupOperationForArrange(add_new_nodes_in_scene = True)
+        group_operation.push()
+
+        # deselect currently selected nodes, and select the new nodes
+        for node in Selection.getAllSelectedObjects():
+            Selection.remove(node)
+        for node in nodes:
+            Selection.add(node)
+
     def _openUrl(self, url: QUrl) -> None:
         QDesktopServices.openUrl(url)

cura/CuraApplication.py

@@ -1,10 +1,11 @@
-# Copyright (c) 2022 Ultimaker B.V.
+# Copyright (c) 2023 UltiMaker
 # Cura is released under the terms of the LGPLv3 or higher.
 import enum
 import os
 import sys
 import tempfile
 import time
+import platform
 from typing import cast, TYPE_CHECKING, Optional, Callable, List, Any, Dict
 
 import numpy
@@ -49,11 +50,11 @@ from UM.Settings.Validator import Validator
 from UM.View.SelectionPass import SelectionPass  # For typing.
 from UM.Workspace.WorkspaceReader import WorkspaceReader
 from UM.i18n import i18nCatalog
+from UM.Version import Version
 from cura import ApplicationMetadata
 from cura.API import CuraAPI
 from cura.API.Account import Account
 from cura.Arranging.ArrangeObjectsJob import ArrangeObjectsJob
-from cura.Arranging.Nest2DArrange import arrange
 from cura.Machines.MachineErrorChecker import MachineErrorChecker
 from cura.Machines.Models.BuildPlateModel import BuildPlateModel
 from cura.Machines.Models.CustomQualityProfilesDropDownMenuModel import CustomQualityProfilesDropDownMenuModel
@@ -114,6 +115,7 @@ from . import CameraAnimation
 from . import CuraActions
 from . import PlatformPhysics
 from . import PrintJobPreviewImageProvider
+from .Arranging.Nest2DArrange import Nest2DArrange
 from .AutoSave import AutoSave
 from .Machines.Models.CompatibleMachineModel import CompatibleMachineModel
 from .Machines.Models.MachineListModel import MachineListModel
@@ -130,7 +132,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 = 21
+    SettingVersion = 22
 
     Created = False
 
@@ -147,6 +149,7 @@ class CuraApplication(QtApplication):
         DefinitionChangesContainer = Resources.UserType + 10
         SettingVisibilityPreset = Resources.UserType + 11
         IntentInstanceContainer = Resources.UserType + 12
+        ImageFiles = Resources.UserType + 13
 
     pyqtEnum(ResourceTypes)
 
@@ -204,6 +207,8 @@ class CuraApplication(QtApplication):
         self._cura_scene_controller = None
         self._machine_error_checker = None
 
+        self._backend_plugins: List[BackendPlugin] = []
+
         self._machine_settings_manager = MachineSettingsManager(self, parent = self)
         self._material_management_model = None
         self._quality_management_model = None
@@ -407,6 +412,9 @@ class CuraApplication(QtApplication):
 
         SettingFunction.registerOperator("extruderValue", self._cura_formula_functions.getValueInExtruder)
         SettingFunction.registerOperator("extruderValues", self._cura_formula_functions.getValuesInAllExtruders)
+        SettingFunction.registerOperator("anyExtruderWithMaterial", self._cura_formula_functions.getExtruderPositionWithMaterial)
+        SettingFunction.registerOperator("anyExtruderNrWithOrDefault",
+                                         self._cura_formula_functions.getAnyExtruderPositionWithOrDefault)
         SettingFunction.registerOperator("resolveOrValue", self._cura_formula_functions.getResolveOrValue)
         SettingFunction.registerOperator("defaultExtruderPosition", self._cura_formula_functions.getDefaultExtruderPosition)
         SettingFunction.registerOperator("valueFromContainer", self._cura_formula_functions.getValueFromContainerAtIndex)
@@ -425,6 +433,7 @@ class CuraApplication(QtApplication):
         Resources.addStorageType(self.ResourceTypes.DefinitionChangesContainer, "definition_changes")
         Resources.addStorageType(self.ResourceTypes.SettingVisibilityPreset, "setting_visibility")
         Resources.addStorageType(self.ResourceTypes.IntentInstanceContainer, "intent")
+        Resources.addStorageType(self.ResourceTypes.ImageFiles, "images")
 
         self._container_registry.addResourceType(self.ResourceTypes.QualityInstanceContainer, "quality")
         self._container_registry.addResourceType(self.ResourceTypes.QualityChangesInstanceContainer, "quality_changes")
@@ -435,6 +444,7 @@ class CuraApplication(QtApplication):
         self._container_registry.addResourceType(self.ResourceTypes.MachineStack, "machine")
         self._container_registry.addResourceType(self.ResourceTypes.DefinitionChangesContainer, "definition_changes")
         self._container_registry.addResourceType(self.ResourceTypes.IntentInstanceContainer, "intent")
+        self._container_registry.addResourceType(self.ResourceTypes.ImageFiles, "images")
 
         Resources.addType(self.ResourceTypes.QmlFiles, "qml")
         Resources.addType(self.ResourceTypes.Firmware, "firmware")
@@ -490,6 +500,36 @@ class CuraApplication(QtApplication):
     def startSplashWindowPhase(self) -> None:
         """Runs preparations that needs to be done before the starting process."""
 
+        self.setRequiredPlugins([
+            # Misc.:
+            "ConsoleLogger",  # You want to be able to read the log if something goes wrong.
+            "CuraEngineBackend",  # Cura is useless without this one since you can't slice.
+            "FileLogger",  # You want to be able to read the log if something goes wrong.
+            "XmlMaterialProfile",  # Cura crashes without this one.
+            "Marketplace",
+            # This contains the interface to enable/disable plug-ins, so if you disable it you can't enable it back.
+            "PrepareStage",  # Cura is useless without this one since you can't load models.
+            "PreviewStage",  # This shows the list of the plugin views that are installed in Cura.
+            "MonitorStage",  # Major part of Cura's functionality.
+            "LocalFileOutputDevice",  # Major part of Cura's functionality.
+            "LocalContainerProvider",  # Cura is useless without any profiles or setting definitions.
+
+            # Views:
+            "SimpleView",  # Dependency of SolidView.
+            "SolidView",  # Displays models. Cura is useless without it.
+
+            # Readers & Writers:
+            "GCodeWriter",  # Cura is useless if it can't write its output.
+            "STLReader",  # Most common model format, so disabling this makes Cura 90% useless.
+            "3MFWriter",  # Required for writing project files.
+
+            # Tools:
+            "CameraTool",  # Needed to see the scene. Cura is useless without it.
+            "SelectionTool",  # Dependency of the rest of the tools.
+            "TranslateTool",  # You'll need this for almost every print.
+        ])
+        # Plugins need to be set here, since in the super the check is done if they are actually loaded.
+
         super().startSplashWindowPhase()
 
         if not self.getIsHeadLess():
@@ -498,33 +538,7 @@ class CuraApplication(QtApplication):
             except FileNotFoundError:
                 Logger.log("w", "Unable to find the window icon.")
 
-        self.setRequiredPlugins([
-            # Misc.:
-            "ConsoleLogger", #You want to be able to read the log if something goes wrong.
-            "CuraEngineBackend", #Cura is useless without this one since you can't slice.
-            "FileLogger", #You want to be able to read the log if something goes wrong.
-            "XmlMaterialProfile", #Cura crashes without this one.
-            "Marketplace", #This contains the interface to enable/disable plug-ins, so if you disable it you can't enable it back.
-            "PrepareStage", #Cura is useless without this one since you can't load models.
-            "PreviewStage", #This shows the list of the plugin views that are installed in Cura.
-            "MonitorStage", #Major part of Cura's functionality.
-            "LocalFileOutputDevice", #Major part of Cura's functionality.
-            "LocalContainerProvider", #Cura is useless without any profiles or setting definitions.
 
-            # Views:
-            "SimpleView", #Dependency of SolidView.
-            "SolidView", #Displays models. Cura is useless without it.
-
-            # Readers & Writers:
-            "GCodeWriter", #Cura is useless if it can't write its output.
-            "STLReader", #Most common model format, so disabling this makes Cura 90% useless.
-            "3MFWriter", #Required for writing project files.
-
-            # Tools:
-            "CameraTool", #Needed to see the scene. Cura is useless without it.
-            "SelectionTool", #Dependency of the rest of the tools.
-            "TranslateTool", #You'll need this for almost every print.
-        ])
         self._i18n_catalog = i18nCatalog("cura")
 
         self._update_platform_activity_timer = QTimer()
@@ -605,6 +619,16 @@ class CuraApplication(QtApplication):
 
     def _onEngineCreated(self):
         self._qml_engine.addImageProvider("print_job_preview", PrintJobPreviewImageProvider.PrintJobPreviewImageProvider())
+        version = Version(self.getVersion())
+        if hasattr(sys, "frozen") and version.hasPostFix() and "beta" not in version.getPostfixType():
+            self._qml_engine.rootObjects()[0].setTitle(f"{ApplicationMetadata.CuraAppDisplayName} {ApplicationMetadata.CuraVersion}")
+            message = Message(
+                self._i18n_catalog.i18nc("@info:warning",
+                                         f"This version is not intended for production use. If you encounter any issues, please report them on our GitHub page, mentioning the full version {self.getVersion()}"),
+                lifetime = 0,
+                title = self._i18n_catalog.i18nc("@info:title", "Nightly build"),
+                message_type = Message.MessageType.WARNING)
+            message.show()
 
     @pyqtProperty(bool)
     def needToShowUserAgreement(self) -> bool:
@@ -788,6 +812,7 @@ class CuraApplication(QtApplication):
 
         self._plugin_registry.addType("profile_reader", self._addProfileReader)
         self._plugin_registry.addType("profile_writer", self._addProfileWriter)
+        self._plugin_registry.addType("backend_plugin", self._addBackendPlugin)
 
         if Platform.isLinux():
             lib_suffixes = {"", "64", "32", "x32"}  # A few common ones on different distributions.
@@ -824,6 +849,8 @@ class CuraApplication(QtApplication):
     def run(self):
         super().run()
 
+        self._log_hardware_info()
+
         if len(ApplicationMetadata.DEPENDENCY_INFO) > 0:
             Logger.debug("Using Conan managed dependencies: " + ", ".join(
                 [dep["recipe"]["id"] for dep in ApplicationMetadata.DEPENDENCY_INFO["installed"] if dep["recipe"]["version"] != "latest"]))
@@ -897,6 +924,14 @@ class CuraApplication(QtApplication):
 
         self.exec()
 
+    def _log_hardware_info(self):
+        hardware_info = platform.uname()
+        Logger.info(f"System: {hardware_info.system}")
+        Logger.info(f"Release: {hardware_info.release}")
+        Logger.info(f"Version: {hardware_info.version}")
+        Logger.info(f"Processor name: {hardware_info.processor}")
+        Logger.info(f"CPU Cores: {os.cpu_count()}")
+
     def __setUpSingleInstanceServer(self):
         if self._use_single_instance:
             self._single_instance.startServer()
@@ -1423,6 +1458,13 @@ class CuraApplication(QtApplication):
     # Single build plate
     @pyqtSlot()
     def arrangeAll(self) -> None:
+        self._arrangeAll(grid_arrangement = False)
+
+    @pyqtSlot()
+    def arrangeAllInGrid(self) -> None:
+        self._arrangeAll(grid_arrangement = True)
+
+    def _arrangeAll(self, *, grid_arrangement: bool) -> None:
         nodes_to_arrange = []
         active_build_plate = self.getMultiBuildPlateModel().activeBuildPlate
         locked_nodes = []
@@ -1452,17 +1494,17 @@ class CuraApplication(QtApplication):
                         locked_nodes.append(node)
                     else:
                         nodes_to_arrange.append(node)
-        self.arrange(nodes_to_arrange, locked_nodes)
+        self.arrange(nodes_to_arrange, locked_nodes, grid_arrangement = grid_arrangement)
 
-    def arrange(self, nodes: List[SceneNode], fixed_nodes: List[SceneNode]) -> None:
+    def arrange(self, nodes: List[SceneNode], fixed_nodes: List[SceneNode], *,  grid_arrangement: bool = False) -> None:
         """Arrange a set of nodes given a set of fixed nodes
 
         :param nodes: nodes that we have to place
         :param fixed_nodes: nodes that are placed in the arranger before finding spots for nodes
+        :param grid_arrangement: If set to true if objects are to be placed in a grid
         """
-
         min_offset = self.getBuildVolume().getEdgeDisallowedSize() + 2  # Allow for some rounding errors
-        job = ArrangeObjectsJob(nodes, fixed_nodes, min_offset = max(min_offset, 8))
+        job = ArrangeObjectsJob(nodes, fixed_nodes, min_offset = max(min_offset, 8), grid_arrange = grid_arrangement)
         job.start()
 
     @pyqtSlot()
@@ -1726,6 +1768,13 @@ class CuraApplication(QtApplication):
     def _addProfileWriter(self, profile_writer):
         pass
 
+    def _addBackendPlugin(self, backend_plugin: "BackendPlugin") -> None:
+        self._container_registry.addAdditionalSettingDefinitionsAppender(backend_plugin)
+        self._backend_plugins.append(backend_plugin)
+
+    def getBackendPlugins(self) -> List["BackendPlugin"]:
+        return self._backend_plugins
+
     @pyqtSlot("QSize")
     def setMinimumWindowSize(self, size):
         main_window = self.getMainWindow()
@@ -1949,7 +1998,8 @@ class CuraApplication(QtApplication):
             if select_models_on_load:
                 Selection.add(node)
         try:
-            arrange(nodes_to_arrange, self.getBuildVolume(), fixed_nodes)
+            arranger = Nest2DArrange(nodes_to_arrange, self.getBuildVolume(), fixed_nodes)
+            arranger.arrange()
         except:
             Logger.logException("e", "Failed to arrange the models")
 
@@ -2076,3 +2126,7 @@ class CuraApplication(QtApplication):
     @classmethod
     def getInstance(cls, *args, **kwargs) -> "CuraApplication":
         return cast(CuraApplication, super().getInstance(**kwargs))
+
+    @pyqtProperty(bool, constant=True)
+    def isEnterprise(self) -> bool:
+        return ApplicationMetadata.IsEnterpriseVersion

cura/CuraPackageManager.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2018 Ultimaker B.V.
+# Copyright (c) 2023 UltiMaker
 # Cura is released under the terms of the LGPLv3 or higher.
 import glob
 import os
@@ -55,7 +55,9 @@ class CuraPackageManager(PackageManager):
     def initialize(self) -> None:
         self._installation_dirs_dict["materials"] = Resources.getStoragePath(CuraApplication.ResourceTypes.MaterialInstanceContainer)
         self._installation_dirs_dict["qualities"] = Resources.getStoragePath(CuraApplication.ResourceTypes.QualityInstanceContainer)
-        self._installation_dirs_dict["variants"] = Resources.getStoragePath(CuraApplication.ResourceTypes.VariantInstanceContainer)
+        self._installation_dirs_dict["variants"] = Resources.getStoragePath(
+            CuraApplication.ResourceTypes.VariantInstanceContainer)
+        self._installation_dirs_dict["images"] = Resources.getStoragePath(CuraApplication.ResourceTypes.ImageFiles)
 
         # Due to a bug in Cura 5.1.0 we needed to change the directory structure of the curapackage on the server side (See SD-3871).
         # Although the material intent profiles will be installed in the `intent` folder, the curapackage from the server side will

cura/Machines/MachineNode.py

@@ -14,6 +14,7 @@ from cura.Machines.QualityChangesGroup import QualityChangesGroup  # To construc
 from cura.Machines.QualityGroup import QualityGroup  # To construct groups of quality profiles that belong together.
 from cura.Machines.QualityNode import QualityNode
 from cura.Machines.VariantNode import VariantNode
+from cura.Machines.MaterialNode import MaterialNode
 import UM.FlameProfiler
 
 
@@ -167,13 +168,20 @@ class MachineNode(ContainerNode):
 
         return self.global_qualities.get(self.preferred_quality_type, next(iter(self.global_qualities.values())))
 
+    def isExcludedMaterial(self, material: MaterialNode) -> 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"]:
+                return True
+        return False
+
     @UM.FlameProfiler.profile
     def _loadAll(self) -> None:
         """(Re)loads all variants under this printer."""
 
         container_registry = ContainerRegistry.getInstance()
         if not self.has_variants:
-            self.variants["empty"] = VariantNode("empty_variant", machine = self)
+            self.variants["empty"] = VariantNode("empty_variant", machine=self)
             self.variants["empty"].materialsChanged.connect(self.materialsChanged)
         else:
             # Find all the variants for this definition ID.

cura/Machines/MaterialNode.py

@@ -31,6 +31,7 @@ class MaterialNode(ContainerNode):
         my_metadata = container_registry.findContainersMetadata(id = container_id)[0]
         self.base_file = my_metadata["base_file"]
         self.material_type = my_metadata["material"]
+        self.brand = my_metadata["brand"]
         self.guid = my_metadata["GUID"]
         self._loadAll()
         container_registry.containerRemoved.connect(self._onRemoved)
@@ -80,6 +81,7 @@ class MaterialNode(ContainerNode):
                 # such as "generic_pla_ultimaker_s5_AA_0.4". So we search with the "base_file" which is the material_root_id.
             else:
                 qualities = container_registry.findInstanceContainersMetadata(type = "quality", definition = self.variant.machine.quality_definition, material = self.base_file)
+
             if not qualities:
                 my_material_type = self.material_type
                 if self.variant.machine.has_variants:
@@ -89,9 +91,22 @@ class MaterialNode(ContainerNode):
                 else:
                     qualities_any_material = container_registry.findInstanceContainersMetadata(type = "quality", definition = self.variant.machine.quality_definition)
 
-                all_material_base_files = {material_metadata["base_file"] for material_metadata in container_registry.findInstanceContainersMetadata(type = "material", material = my_material_type)}
+                # First we attempt to find materials that have the same brand but not the right color
+                all_material_base_files_right_brand = {material_metadata["base_file"] for material_metadata in container_registry.findInstanceContainersMetadata(type = "material", material = my_material_type, brand = self.brand)}
 
-                qualities.extend((quality for quality in qualities_any_material if quality.get("material") in all_material_base_files))
+                right_brand_no_color_qualities = [quality for quality in qualities_any_material if quality.get("material") in all_material_base_files_right_brand]
+
+                if right_brand_no_color_qualities:
+                    # We found qualties for materials with the right brand but not with the right color. Use those.
+                    qualities.extend(right_brand_no_color_qualities)
+                else:
+                    # Fall back to generic
+                    all_material_base_files = {material_metadata["base_file"] for material_metadata in
+                                               container_registry.findInstanceContainersMetadata(type="material",
+                                                                                                 material=my_material_type)}
+                    no_brand_no_color_qualities = (quality for quality in qualities_any_material if
+                                                   quality.get("material") in all_material_base_files)
+                    qualities.extend(no_brand_no_color_qualities)
 
                 if not qualities:  # No quality profiles found. Go by GUID then.
                     my_guid = self.guid

cura/Machines/Models/CompatibleMachineModel.py

@@ -54,6 +54,8 @@ class CompatibleMachineModel(ListModel):
 
                 # initialize & add current active material:
                 for extruder in printer.extruders:
+                    if not extruder.activeMaterial:
+                        continue
                     materials = [_makeMaterial(
                         extruder.activeMaterial.brand, extruder.activeMaterial.name, extruder.activeMaterial.color)]
                     extruder_configs[extruder.getPosition()] = {

cura/Machines/Models/IntentCategoryModel.py

@@ -53,6 +53,12 @@ class IntentCategoryModel(ListModel):
                 "name": catalog.i18nc("@label", "Draft"),
                 "description": catalog.i18nc("@text", "The draft profile is designed to print initial prototypes and concept validation with the intent of significant print time reduction.")
             }
+            cls._translations["annealing"] = {
+                "name": catalog.i18nc("@label", "Annealing"),
+                "description": catalog.i18nc("@text",
+                                             "The annealing profile requires post-processing in an oven after the print is finished. This profile retains the dimensional accuracy of the printed part after annealing and improves strength, stiffness, and thermal resistance.")
+
+            }
         return cls._translations
 
     def __init__(self, intent_category: str) -> None:

cura/Machines/Models/IntentSelectionModel.py

@@ -1,29 +1,32 @@
-# Copyright (c) 2022 Ultimaker B.V.
+# Copyright (c) 2023 UltiMaker
 # Cura is released under the terms of the LGPLv3 or higher.
 
 import collections
-from typing import OrderedDict, Optional
+from typing import Optional
 
-from PyQt6.QtCore import Qt, QTimer, QObject
+from PyQt6.QtCore import Qt, QTimer, QObject, QUrl
 
 import cura
 from UM import i18nCatalog
 from UM.Logger import Logger
 from UM.Qt.ListModel import ListModel
+from UM.Resources import Resources
 from UM.Settings.ContainerRegistry import ContainerRegistry
 from UM.Settings.Interfaces import ContainerInterface
+
+from cura.Machines.Models.IntentCategoryModel import IntentCategoryModel
 from cura.Settings.IntentManager import IntentManager
 
 catalog = i18nCatalog("cura")
 
 
 class IntentSelectionModel(ListModel):
-
     NameRole = Qt.ItemDataRole.UserRole + 1
     IntentCategoryRole = Qt.ItemDataRole.UserRole + 2
     WeightRole = Qt.ItemDataRole.UserRole + 3
     DescriptionRole = Qt.ItemDataRole.UserRole + 4
     IconRole = Qt.ItemDataRole.UserRole + 5
+    CustomIconRole = Qt.ItemDataRole.UserRole + 6
 
     def __init__(self, parent: Optional[QObject] = None) -> None:
         super().__init__(parent)
@@ -33,6 +36,7 @@ class IntentSelectionModel(ListModel):
         self.addRoleName(self.WeightRole, "weight")
         self.addRoleName(self.DescriptionRole, "description")
         self.addRoleName(self.IconRole, "icon")
+        self.addRoleName(self.CustomIconRole, "custom_icon")
 
         application = cura.CuraApplication.CuraApplication.getInstance()
 
@@ -53,30 +57,8 @@ class IntentSelectionModel(ListModel):
 
         self._onChange()
 
-    @staticmethod
-    def _getDefaultProfileInformation() -> OrderedDict[str, dict]:
-        """ Default information user-visible string. Ordered by weight. """
-        default_profile_information = collections.OrderedDict()
-        default_profile_information["default"] = {
-            "name": catalog.i18nc("@label", "Default"),
-            "icon": "GearCheck"
-        }
-        default_profile_information["visual"] = {
-            "name": catalog.i18nc("@label", "Visual"),
-            "description": catalog.i18nc("@text", "The visual profile is designed to print visual prototypes and models with the intent of high visual and surface quality."),
-            "icon" : "Visual"
-        }
-        default_profile_information["engineering"] = {
-            "name": catalog.i18nc("@label", "Engineering"),
-            "description": catalog.i18nc("@text", "The engineering profile is designed to print functional prototypes and end-use parts with the intent of better accuracy and for closer tolerances."),
-            "icon": "Nut"
-        }
-        default_profile_information["quick"] = {
-            "name": catalog.i18nc("@label", "Draft"),
-            "description": catalog.i18nc("@text", "The draft profile is designed to print initial prototypes and concept validation with the intent of significant print time reduction."),
-            "icon": "SpeedOMeter"
-        }
-        return default_profile_information
+    _default_intent_categories = ["default", "visual", "engineering", "quick", "annealing"]
+    _icons = {"default": "GearCheck", "visual": "Visual", "engineering": "Nut", "quick": "SpeedOMeter", "annealing": "Anneal"}
 
     def _onContainerChange(self, container: ContainerInterface) -> None:
         """Updates the list of intents if an intent profile was added or removed."""
@@ -89,38 +71,63 @@ class IntentSelectionModel(ListModel):
 
     def _update(self) -> None:
         Logger.log("d", "Updating {model_class_name}.".format(model_class_name = self.__class__.__name__))
-
-        global_stack = cura.CuraApplication.CuraApplication.getInstance().getGlobalContainerStack()
+        cura_application = cura.CuraApplication.CuraApplication.getInstance()
+        global_stack = cura_application.getGlobalContainerStack()
         if global_stack is None:
             self.setItems([])
             Logger.log("d", "No active GlobalStack, set quality profile model as empty.")
             return
 
         # Check for material compatibility
-        if not cura.CuraApplication.CuraApplication.getInstance().getMachineManager().activeMaterialsCompatible():
+        if not cura_application.getMachineManager().activeMaterialsCompatible():
             Logger.log("d", "No active material compatibility, set quality profile model as empty.")
             self.setItems([])
             return
 
-        default_profile_info = self._getDefaultProfileInformation()
-
         available_categories = IntentManager.getInstance().currentAvailableIntentCategories()
+
         result = []
-        for i, category in enumerate(available_categories):
-            profile_info = default_profile_info.get(category, {})
+        for category in available_categories:
 
-            try:
-                weight = list(default_profile_info.keys()).index(category)
-            except ValueError:
-                weight = len(available_categories) + i
+            if category in self._default_intent_categories:
+                result.append({
+                    "name": IntentCategoryModel.translation(category, "name", category.title()),
+                    "description": IntentCategoryModel.translation(category, "description", None),
+                    "icon": self._icons[category],
+                    "custom_icon": None,
+                    "intent_category": category,
+                    "weight": self._default_intent_categories.index(category),
+                })
+            else:
+                # There can be multiple intents with the same category, use one of these
+                # intent-metadata's for the icon/description defintions for the intent
 
-            result.append({
-                "name": profile_info.get("name", category.title()),
-                "description": profile_info.get("description", None),
-                "icon" : profile_info.get("icon", ""),
-                "intent_category": category,
-                "weight": weight,
-            })
+
+
+                intent_metadata = cura_application.getContainerRegistry().findContainersMetadata(type="intent",
+                                                                                                 definition=global_stack.findInstanceContainerDefinitionId(global_stack.definition),
+                                                                                                 intent_category=category)[0]
+
+                intent_name = intent_metadata.get("name", category.title())
+                icon = intent_metadata.get("icon", None)
+                description = intent_metadata.get("description", None)
+
+                if icon is not None and icon != '':
+                    try:
+                        icon = QUrl.fromLocalFile(
+                            Resources.getPath(cura.CuraApplication.CuraApplication.ResourceTypes.ImageFiles, icon))
+                    except (FileNotFoundError, NotADirectoryError, PermissionError):
+                        Logger.log("e", f"Icon file for intent {intent_name} not found.")
+                        icon = None
+
+                result.append({
+                    "name": intent_name,
+                    "description": description,
+                    "custom_icon": icon,
+                    "icon": None,
+                    "intent_category": category,
+                    "weight": 5,
+                })
 
         result.sort(key=lambda k: k["weight"])
 

cura/Machines/Models/MachineListModel.py

@@ -110,22 +110,22 @@ class MachineListModel(ListModel):
 
         for abstract_machine in abstract_machine_stacks:
             definition_id = abstract_machine.definition.getId()
-            online_machine_stacks = machines_manager.getMachinesWithDefinition(definition_id, online_only = True)
+            connected_machine_stacks = machines_manager.getMachinesWithDefinition(definition_id, online_only = False)
 
-            online_machine_stacks = list(filter(lambda machine: machine.hasNetworkedConnection(), online_machine_stacks))
-            online_machine_stacks.sort(key=lambda machine: machine.getName().upper())
+            connected_machine_stacks = list(filter(lambda machine: machine.hasNetworkedConnection(), connected_machine_stacks))
+            connected_machine_stacks.sort(key=lambda machine: machine.getName().upper())
 
             if abstract_machine in other_machine_stacks:
                 other_machine_stacks.remove(abstract_machine)
 
-            if abstract_machine in online_machine_stacks:
-                online_machine_stacks.remove(abstract_machine)
+            if abstract_machine in connected_machine_stacks:
+                connected_machine_stacks.remove(abstract_machine)
 
             # Create a list item for abstract machine
-            self.addItem(abstract_machine, True, len(online_machine_stacks))
+            self.addItem(abstract_machine, True, len(connected_machine_stacks))
 
             # Create list of machines that are children of the abstract machine
-            for stack in online_machine_stacks:
+            for stack in connected_machine_stacks:
                 if self._show_cloud_printers:
                     self.addItem(stack, True)
                 # Remove this machine from the other stack list

cura/Machines/Models/MaterialBrandsModel.py

@@ -44,6 +44,10 @@ class MaterialBrandsModel(BaseMaterialsModel):
             if bool(container_node.getMetaDataEntry("removed", False)):
                 continue
 
+            # Ignore materials that are marked as not visible for whatever reason
+            if not bool(container_node.getMetaDataEntry("visible", True)):
+                continue
+
             # Add brands we haven't seen yet to the dict, skipping generics
             brand = container_node.getMetaDataEntry("brand", "")
             if brand.lower() == "generic":

cura/Machines/VariantNode.py

@@ -60,7 +60,7 @@ 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 material["id"] not in self.machine.exclude_materials]
+        filtered_materials = [material for material in materials if not self.machine.isExcludedMaterial(material)]
 
         for material in filtered_materials:
             base_file = material["base_file"]

cura/MultiplyObjectsJob.py

@@ -14,17 +14,19 @@ from UM.Operations.TranslateOperation import TranslateOperation
 from UM.Scene.Iterator.DepthFirstIterator import DepthFirstIterator
 from UM.Scene.SceneNode import SceneNode
 from UM.i18n import i18nCatalog
-from cura.Arranging.Nest2DArrange import arrange, createGroupOperationForArrange
+from cura.Arranging.GridArrange import GridArrange
+from cura.Arranging.Nest2DArrange import Nest2DArrange
 
 i18n_catalog = i18nCatalog("cura")
 
 
 class MultiplyObjectsJob(Job):
-    def __init__(self, objects, count, min_offset = 8):
+    def __init__(self, objects, count: int, min_offset: int = 8 ,* , grid_arrange: bool = False):
         super().__init__()
         self._objects = objects
-        self._count = count
-        self._min_offset = min_offset
+        self._count: int = count
+        self._min_offset: int = min_offset
+        self._grid_arrange: bool = grid_arrange
 
     def run(self) -> None:
         status_message = Message(i18n_catalog.i18nc("@info:status", "Multiplying and placing objects"), lifetime = 0,
@@ -39,7 +41,7 @@ class MultiplyObjectsJob(Job):
 
         root = scene.getRoot()
 
-        processed_nodes = []  # type: List[SceneNode]
+        processed_nodes: List[SceneNode] = []
         nodes = []
 
         fixed_nodes = []
@@ -76,12 +78,12 @@ class MultiplyObjectsJob(Job):
         found_solution_for_all = True
         group_operation = GroupedOperation()
         if nodes:
-            group_operation, not_fit_count = createGroupOperationForArrange(nodes,
-                                                                            Application.getInstance().getBuildVolume(),
-                                                                            fixed_nodes,
-                                                                            factor = 10000,
-                                                                            add_new_nodes_in_scene = True)
-            found_solution_for_all = not_fit_count == 0
+            if self._grid_arrange:
+                arranger = GridArrange(nodes, Application.getInstance().getBuildVolume(), fixed_nodes)
+            else:
+                arranger = Nest2DArrange(nodes, Application.getInstance().getBuildVolume(), fixed_nodes, factor=1000)
+
+            group_operation, not_fit_count = arranger.createGroupOperationForArrange(add_new_nodes_in_scene=True)
 
         if nodes_to_add_without_arrange:
             for nested_node in nodes_to_add_without_arrange:

cura/OAuth2/AuthorizationRequestHandler.py

@@ -6,6 +6,7 @@ from threading import Lock  # To turn an asynchronous call synchronous.
 from typing import Optional, Callable, Tuple, Dict, Any, List, TYPE_CHECKING
 from urllib.parse import parse_qs, urlparse
 
+from UM.Logger import Logger
 from cura.OAuth2.Models import AuthenticationResponse, ResponseData, HTTP_STATUS
 from UM.i18n import i18nCatalog
 
@@ -70,11 +71,13 @@ class AuthorizationRequestHandler(BaseHTTPRequestHandler):
         code = self._queryGet(query, "code")
         state = self._queryGet(query, "state")
         if state != self.state:
+            Logger.log("w", f"The provided state was not correct. Got {state} and expected {self.state}")
             token_response = AuthenticationResponse(
                 success = False,
                 err_message = catalog.i18nc("@message", "The provided state is not correct.")
             )
         elif code and self.authorization_helpers is not None and self.verification_code is not None:
+            Logger.log("d", "Timeout when authenticating with the account server.")
             token_response = AuthenticationResponse(
                 success = False,
                 err_message = catalog.i18nc("@message", "Timeout when authenticating with the account server.")
@@ -92,6 +95,7 @@ class AuthorizationRequestHandler(BaseHTTPRequestHandler):
 
         elif self._queryGet(query, "error_code") == "user_denied":
             # Otherwise we show an error message (probably the user clicked "Deny" in the auth dialog).
+            Logger.log("d", "User did not give the required permission when authorizing this application")
             token_response = AuthenticationResponse(
                 success = False,
                 err_message = catalog.i18nc("@message", "Please give the required permissions when authorizing this application.")
@@ -99,6 +103,7 @@ class AuthorizationRequestHandler(BaseHTTPRequestHandler):
 
         else:
             # We don't know what went wrong here, so instruct the user to check the logs.
+            Logger.log("w", f"Unexpected error when logging in. Error_code: {self._queryGet(query, 'error_code')}, State: {state}")
             token_response = AuthenticationResponse(
                 success = False,
                 error_message = catalog.i18nc("@message", "Something unexpected happened when trying to log in, please try again.")

cura/PlatformPhysics.py

@@ -85,7 +85,7 @@ class PlatformPhysics:
                 move_vector = move_vector.set(y = -bbox.bottom + z_offset)
 
             # If there is no convex hull for the node, start calculating it and continue.
-            if not node.getDecorator(ConvexHullDecorator) and not node.callDecoration("isNonPrintingMesh"):
+            if not node.getDecorator(ConvexHullDecorator) and not node.callDecoration("isNonPrintingMesh") and node.callDecoration("getLayerData") is None:
                 node.addDecorator(ConvexHullDecorator())
 
             # only push away objects if this node is a printing mesh

cura/Scene/ConvexHullDecorator.py

@@ -111,11 +111,7 @@ class ConvexHullDecorator(SceneNodeDecorator):
 
         # Parent can be None if node is just loaded.
         if self._isSingularOneAtATimeNode():
-            hull = self.getConvexHullHeadFull()
-            if hull is None:
-                return None
-            hull = self._add2DAdhesionMargin(hull)
-            return hull
+            return self.getConvexHullHeadFull()
 
         return self._compute2DConvexHull()
 
@@ -323,6 +319,7 @@ class ConvexHullDecorator(SceneNodeDecorator):
 
     def _compute2DConvexHeadFull(self) -> Optional[Polygon]:
         convex_hull = self._compute2DConvexHull()
+        convex_hull = self._add2DAdhesionMargin(convex_hull)
         if convex_hull:
             return convex_hull.getMinkowskiHull(self._getHeadAndFans())
         return None

cura/Settings/CuraContainerStack.py

@@ -359,7 +359,7 @@ class CuraContainerStack(ContainerStack):
         return self.definition
 
     @classmethod
-    def _findInstanceContainerDefinitionId(cls, machine_definition: DefinitionContainerInterface) -> str:
+    def findInstanceContainerDefinitionId(cls, machine_definition: DefinitionContainerInterface) -> str:
         """Find the ID that should be used when searching for instance containers for a specified definition.
 
         This handles the situation where the definition specifies we should use a different definition when
@@ -379,7 +379,7 @@ class CuraContainerStack(ContainerStack):
             Logger.log("w", "Unable to find parent definition {parent} for machine {machine}", parent = quality_definition, machine = machine_definition.id) #type: ignore
             return machine_definition.id #type: ignore
 
-        return cls._findInstanceContainerDefinitionId(definitions[0])
+        return cls.findInstanceContainerDefinitionId(definitions[0])
 
     def getExtruderPositionValueWithDefault(self, key):
         """getProperty for extruder positions, with translation from -1 to default extruder number"""

cura/Settings/CuraFormulaFunctions.py

@@ -58,9 +58,7 @@ class CuraFormulaFunctions:
 
         return value
 
-    # Gets all extruder values as a list for the given property.
-    def getValuesInAllExtruders(self, property_key: str,
-                                context: Optional["PropertyEvaluationContext"] = None) -> List[Any]:
+    def _getActiveExtruders(self, context: Optional["PropertyEvaluationContext"] = None) -> List[str]:
         machine_manager = self._application.getMachineManager()
         extruder_manager = self._application.getExtruderManager()
 
@@ -73,7 +71,17 @@ class CuraFormulaFunctions:
             # only include values from extruders that are "active" for the current machine instance
             if int(extruder.getMetaDataEntry("position")) >= global_stack.getProperty("machine_extruder_count", "value", context = context):
                 continue
+            result.append(extruder)
 
+        return result
+
+    # Gets all extruder values as a list for the given property.
+    def getValuesInAllExtruders(self, property_key: str,
+                                context: Optional["PropertyEvaluationContext"] = None) -> List[Any]:
+        global_stack = self._application.getMachineManager().activeMachine
+
+        result = []
+        for extruder in self._getActiveExtruders(context):
             value = extruder.getRawProperty(property_key, "value", context = context)
 
             if value is None:
@@ -89,6 +97,25 @@ class CuraFormulaFunctions:
 
         return result
 
+    # Get the first extruder that adheres to a specific (boolean) property, like 'material_is_support_material'.
+    def getAnyExtruderPositionWithOrDefault(self, filter_key: str,
+                                            context: Optional["PropertyEvaluationContext"] = None) -> str:
+        for extruder in self._getActiveExtruders(context):
+            value = extruder.getRawProperty(filter_key, "value", context=context)
+            if value is None or not value:
+                continue
+            return str(extruder.position)
+
+    # Get the first extruder with material that adheres to a specific (boolean) property, like 'material_is_support_material'.
+    def getExtruderPositionWithMaterial(self, filter_key: str,
+                               context: Optional["PropertyEvaluationContext"] = None) -> str:
+        for extruder in self._getActiveExtruders(context):
+            material_container = extruder.material
+            value = material_container.getProperty(filter_key, "value", context)
+            if value is not None:
+                return str(extruder.position)
+        return self.getDefaultExtruderPosition()
+
     # Get the resolve value or value for a given key.
     def getResolveOrValue(self, property_key: str, context: Optional["PropertyEvaluationContext"] = None) -> Any:
         machine_manager = self._application.getMachineManager()

cura/Settings/DatabaseHandlers/IntentDatabaseHandler.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2021 Ultimaker B.V.
+# Copyright (c) 2023 UltiMaker
 # Cura is released under the terms of the LGPLv3 or higher.
 
 from UM.Settings.SQLQueryFactory import SQLQueryFactory
@@ -10,8 +10,8 @@ class IntentDatabaseHandler(DatabaseMetadataContainerController):
     """The Database handler for Intent containers"""
 
     def __init__(self) -> None:
-        super().__init__(SQLQueryFactory(table = "intent",
-                                         fields = {
+        super().__init__(SQLQueryFactory(table="intent",
+                                         fields={
                                              "id": "text",
                                              "name": "text",
                                              "quality_type": "text",
@@ -20,6 +20,8 @@ class IntentDatabaseHandler(DatabaseMetadataContainerController):
                                              "definition": "text",
                                              "material": "text",
                                              "version": "text",
-                                             "setting_version": "text"
+                                             "setting_version": "text",
+                                             "icon": "text",
+                                             "description": "text",
                                          }))
         self._container_type = InstanceContainer

cura/Settings/ExtruderManager.py

@@ -466,7 +466,6 @@ class ExtruderManager(QObject):
             return False
         return list(active_material_node_qualities.keys())[0] != "empty_quality"
 
-
     @pyqtSlot(str, result="QVariant")
     def getInstanceExtruderValues(self, key: str) -> List:
         """Get all extruder values for a certain setting.

cura/Settings/cura_empty_instance_containers.py

@@ -28,6 +28,7 @@ empty_material_container.setMetaDataEntry("type", "material")
 empty_material_container.setMetaDataEntry("base_file", "empty_material")
 empty_material_container.setMetaDataEntry("GUID", "FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF")
 empty_material_container.setMetaDataEntry("material", "empty")
+empty_material_container.setMetaDataEntry("brand", "empty_brand")
 
 # Empty quality
 EMPTY_QUALITY_CONTAINER_ID = "empty_quality"

cura/UI/ObjectsModel.py

@@ -69,7 +69,7 @@ class ObjectsModel(ListModel):
         self._group_name_template = catalog.i18nc("@label", "Group #{group_nr}")
         self._group_name_prefix = self._group_name_template.split("#")[0]
 
-        self._naming_regex = re.compile("^(.+)\(([0-9]+)\)$")
+        self._naming_regex = re.compile(r"^(.+)\(([0-9]+)\)$")
 
     def setActiveBuildPlate(self, nr: int) -> None:
         if self._build_plate_number != nr:

cura/UltimakerCloud/CloudMaterialSync.py

@@ -148,6 +148,9 @@ class CloudMaterialSync(QObject):
                 continue
             if metadata["id"] == "empty_material":  # Don't export the empty material.
                 continue
+            # Ignore materials that are marked as not visible for whatever reason
+            if not bool(metadata.get("visible", True)):
+                continue
             material = registry.findContainers(id = metadata["id"])[0]
             suffix = registry.getMimeTypeForContainer(type(material)).preferredSuffix
             filename = metadata["id"] + "." + suffix

docs/profiles/getting_a_setting_value.md

@@ -54,8 +54,12 @@ There are also a few extra things that can be used in these expressions:
 * The function `extruderValue(extruder, key)` will evaluate a particular setting for a particular extruder.
 * The function `resolveOrValue(key)` will perform the full setting evaluation as described in this document for the current context (so if this setting is being evaluated for the second extruder it would perform it as if coming from the second extruder).
 * The function `defaultExtruderPosition()` will get the first extruder that is not disabled. For instance, if a printer has three extruders but the first is disabled, this would return `1` to indicate the second extruder (0-indexed).
+* The function `anyExtruderNrWithOrDefault(key)` will filter the list of extruders on the key, and then give the first
+  index for which it is true, or if none of them are, the default one as specified by the 'default extruder position'
+  function above.
+* The function `anyExtruderWithMaterial(key)` will filter the list of extruders on the key of material quality, and then give the first index for which it is true, or if none of them are, the default one as specified by the 'default extruder position' function above. 
 * The function `valueFromContainer(key, index)` will get a setting value from the global stack, but skip the first few containers in that stack. It will skip until it reaches a particular index in the container stack.
-* The function `valueFromExtruderContainer(key, index)` will get a setting value from the current extruder stack, but skip the first few containers in that stack. It will skip until it reaches a particular index in the container stack.
+* The function `extruderValueFromContainer(key, index)` will get a setting value from the current extruder stack, but skip the first few containers in that stack. It will skip until it reaches a particular index in the container stack.
 
 CuraEngine
 ----

packaging/AppImage-builder/AppImageBuilder.yml.jinja

@@ -0,0 +1,141 @@
+version: 1
+
+AppDir:
+  path: {{ app_dir }}
+  app_info:
+    id: com.ultimaker.cura
+    name: UltiMaker Cura
+    icon: {{ icon }}
+    version: {{ version }}
+    exec: UltiMaker-Cura
+    exec_args: $@
+  apt:
+    arch:
+    - amd64
+    allow_unauthenticated: true
+    sources:
+    - sourceline: deb http://nl.archive.ubuntu.com/ubuntu/ jammy main restricted
+    - sourceline: deb http://nl.archive.ubuntu.com/ubuntu/ jammy-updates main restricted
+    - sourceline: deb http://nl.archive.ubuntu.com/ubuntu/ jammy universe
+    - sourceline: deb http://nl.archive.ubuntu.com/ubuntu/ jammy-updates universe
+    - sourceline: deb http://nl.archive.ubuntu.com/ubuntu/ jammy multiverse
+    - sourceline: deb http://nl.archive.ubuntu.com/ubuntu/ jammy-updates multiverse
+    - sourceline: deb http://nl.archive.ubuntu.com/ubuntu/ jammy-backports main restricted
+        universe multiverse
+    - sourceline: deb http://security.ubuntu.com/ubuntu jammy-security main restricted
+    - sourceline: deb http://security.ubuntu.com/ubuntu jammy-security universe
+    - sourceline: deb http://security.ubuntu.com/ubuntu jammy-security multiverse
+    - sourceline: deb https://releases.jfrog.io/artifactory/jfrog-debs xenial contrib
+    - sourceline: deb http://apt.llvm.org/jammy/ llvm-toolchain-jammy-14 main
+    - sourceline: deb https://ppa.launchpadcontent.net/ubuntu-toolchain-r/test/ubuntu/
+        jammy main
+    - sourceline: deb https://ppa.launchpadcontent.net/deadsnakes/ppa/ubuntu/ jammy
+        main
+    - sourceline: deb [arch=amd64] https://packages.microsoft.com/repos/ms-teams stable
+        main
+    - sourceline: deb https://ppa.launchpadcontent.net/ppa-verse/cling/ubuntu/ jammy
+        main
+    - sourceline: deb [arch=amd64] https://dl.google.com/linux/chrome/deb/ stable
+        main
+    - sourceline: deb [signed-by=/usr/share/keyrings/nodesource.gpg] https://deb.nodesource.com/node_14.x
+        jammy main
+    - sourceline: deb [arch=amd64 signed-by=/usr/share/keyrings/transip-stack.gpg]
+        https://mirror.transip.net/stack/software/deb/Ubuntu_22.04/ ./
+    - sourceline: deb http://repository.spotify.com stable non-free
+    - sourceline: deb [arch=amd64,arm64,armhf] http://packages.microsoft.com/repos/code
+        stable main
+    - sourceline: deb https://packagecloud.io/slacktechnologies/slack/debian/ jessie
+        main
+    include:
+      - libc6:amd64
+      - xdg-desktop-portal-kde:amd64
+      - libcap2:amd64
+      - libcom-err2:amd64
+      - libdbus-1-3:amd64
+      - libgpg-error0:amd64
+      - libgtk-3-common
+      - libkeyutils1:amd64
+      - libllvm13
+      - liblzma5:amd64
+      - libpcre3:amd64
+      - libqt6gui6
+      - libqt6qml6
+      - libqt6qmlworkerscript6
+      - libqt6quick6
+      - libselinux1:amd64
+      - libtinfo6:amd64
+      - qml6-module-qtqml-workerscript:amd64
+      - qml6-module-qtquick:amd64
+      - qt6-gtk-platformtheme:amd64
+      - qt6-qpa-plugins:amd64
+        # x11
+      - libx11-6
+      - libx11-xcb1
+      - libxcb1
+      - libxcb-render0
+      - libxcb-xfixes0
+      - libxcb-shape0
+      - libxcb-dri2-0
+      - libxcb-shm0
+      - libxcb-glx0
+      - libxcb-present0
+      - libxcb-dri3-0
+        # graphic libraries interface (safe graphics bundle including drivers, acceleration may not work in some systems)
+      - libglvnd0
+      - libglx0
+      - libglapi-mesa
+      - libgl1
+      - libegl1
+      - libgbm1
+      - libdrm2
+      - libglx-mesa0
+      - libgl1-amber-dri
+      - libgl1-mesa-dri
+      - mesa-utils
+      - libgl1-mesa-glx
+      - libdrm-amdgpu1
+      - libdrm-nouveau2
+    exclude:
+      - hicolor-icon-theme
+      - adwaita-icon-theme
+      - humanity-icon-theme
+  files:
+    include: []
+    exclude:
+    - usr/share/man
+    - usr/share/doc/*/README.*
+    - usr/share/doc/*/changelog.*
+    - usr/share/doc/*/NEWS.*
+    - usr/share/doc/*/TODO.*
+  runtime:
+    env:
+      APPDIR_LIBRARY_PATH: "$APPDIR/usr/lib/x86_64-linux-gnu:$APPDIR/lib/x86_64-linux-gnu:$APPDIR/usr/lib:$APPDIR/usr/lib/x86_64-linux-gnu/gdk-pixbuf-2.0/2.10.0/loaders"
+      PYTHONPATH: "$APPDIR"
+      QT_PLUGIN_PATH: "$APPDIR/qt/plugins"
+      QML2_IMPORT_PATH: "$APPDIR/qt/qml"
+      QT_QPA_PLATFORMTHEME: xdgdesktopportal
+  test:
+    fedora-30:
+      image: appimagecrafters/tests-env:fedora-30
+      command: ./AppRun
+      use_host_x: True
+    debian-stable:
+      image: appimagecrafters/tests-env:debian-stable
+      command: ./AppRun
+      use_host_x: True
+    archlinux-latest:
+      image: appimagecrafters/tests-env:archlinux-latest
+      command: ./AppRun
+      use_host_x: True
+    centos-7:
+      image: appimagecrafters/tests-env:centos-7
+      command: ./AppRun
+      use_host_x: True
+    ubuntu-xenial:
+      image: appimagecrafters/tests-env:ubuntu-xenial
+      command: ./AppRun
+      use_host_x: True
+AppImage:
+  arch: {{ arch }}
+  file_name: {{ file_name }}
+  update-information: guess

packaging/AppImage-builder/create_appimage.py

@@ -0,0 +1,102 @@
+# Copyright (c) 2023 UltiMaker
+# Cura is released under the terms of the LGPLv3 or higher.
+
+import argparse
+import os
+import shutil
+import subprocess
+
+from pathlib import Path
+
+from jinja2 import Template
+
+
+def prepare_workspace(dist_path, appimage_filename):
+    """
+    Prepare the workspace for building the AppImage.
+    :param dist_path: Path to the distribution of Cura created with pyinstaller.
+    :param appimage_filename: name of the AppImage file.
+    :return:
+    """
+    if not os.path.exists(dist_path):
+        raise RuntimeError(f"The dist_path {dist_path} does not exist.")
+
+    if os.path.exists(os.path.join(dist_path, appimage_filename)):
+        os.remove(os.path.join(dist_path, appimage_filename))
+
+    if not os.path.exists("AppDir"):
+        shutil.move(dist_path, "AppDir")
+    else:
+        print(f"AppDir already exists, assuming it is already prepared.")
+
+    copy_files("AppDir")
+
+
+def build_appimage(dist_path, version, appimage_filename):
+    """
+    Creates an AppImage file from the build artefacts created so far.
+    """
+    generate_appimage_builder_config(dist_path, version, appimage_filename)
+    create_appimage()
+    sign_appimage(appimage_filename)
+
+
+def generate_appimage_builder_config(dist_path, version, appimage_filename):
+    with open(os.path.join(Path(__file__).parent, "AppImageBuilder.yml.jinja"), "r") as appimage_builder_file:
+        appimage_builder = appimage_builder_file.read()
+
+    template = Template(appimage_builder)
+    appimage_builder = template.render(app_dir = "./AppDir",
+                                       icon = "cura-icon.png",
+                                       version = version,
+                                       arch = "x86_64",
+                                       file_name = appimage_filename)
+
+    with open(os.path.join(Path(__file__).parent, "AppImageBuilder.yml"), "w") as appimage_builder_file:
+        appimage_builder_file.write(appimage_builder)
+
+
+def copy_files(dist_path):
+    """
+    Copy metadata files for the metadata of the AppImage.
+    """
+    copied_files = {
+        os.path.join("..", "icons", "cura-icon.svg"): os.path.join("usr", "share", "icons", "hicolor", "scalable", "apps", "cura-icon.svg"),
+        os.path.join("..", "icons", "cura-icon_64x64.png"): os.path.join("usr", "share", "icons", "hicolor", "64x64", "apps", "cura-icon.png"),
+        os.path.join("..", "icons", "cura-icon_128x128.png"): os.path.join("usr", "share", "icons", "hicolor", "128x128", "apps", "cura-icon.png"),
+        os.path.join("..", "icons", "cura-icon_256x256.png"): os.path.join("usr", "share", "icons", "hicolor", "256x256", "apps", "cura-icon.png"),
+        os.path.join("..", "icons", "cura-icon_256x256.png"): "cura-icon.png",
+    }
+
+    # TODO: openssl.cnf ???
+
+    packaging_dir = os.path.dirname(__file__)
+    for source, dest in copied_files.items():
+        dest_file_path = os.path.join(dist_path, dest)
+        os.makedirs(os.path.dirname(dest_file_path), exist_ok = True)
+        shutil.copyfile(os.path.join(packaging_dir, source), dest_file_path)
+
+
+def create_appimage():
+    appimagetool = os.getenv("APPIMAGEBUILDER_LOCATION", "appimage-builder-x86_64.AppImage")
+    command = [appimagetool, "--recipe", os.path.join(Path(__file__).parent, "AppImageBuilder.yml"), "--skip-test"]
+    result = subprocess.call(command)
+    if result != 0:
+        raise RuntimeError(f"The AppImageTool command returned non-zero: {result}")
+
+
+def sign_appimage(appimage_filename):
+    command = ["gpg", "--yes", "--armor", "--detach-sig", appimage_filename]
+    result = subprocess.call(command)
+    if result != 0:
+        raise RuntimeError(f"The GPG command returned non-zero: {result}")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description = "Create AppImages of Cura.")
+    parser.add_argument("dist_path", type = str, help = "Path to where PyInstaller installed the distribution of Cura.")
+    parser.add_argument("version", type = str, help = "Full version number of Cura (e.g. '5.1.0-beta')")
+    parser.add_argument("filename", type = str, help = "Filename of the AppImage (e.g. 'UltiMaker-Cura-5.1.0-beta-Linux-X64.AppImage')")
+    args = parser.parse_args()
+    prepare_workspace(args.dist_path, args.filename)
+    build_appimage(args.dist_path, args.version, args.filename)

packaging/AppImage/AppRun

@@ -1,4 +1,4 @@
-#!/bin/sh
+#!/bin/bash
 
 scriptdir=$(dirname $0)
 

packaging/AppImage/create_appimage.py

@@ -30,6 +30,10 @@ def copy_metadata_files(dist_path, version):
     Copy metadata files for the metadata of the AppImage.
     """
     copied_files = {
+        os.path.join("..", "icons", "cura-icon.svg"):         os.path.join("usr", "share", "icons", "hicolor", "scalable", "apps", "cura-icon.svg"),
+        os.path.join("..", "icons", "cura-icon_64x64.png"):   os.path.join("usr", "share", "icons", "hicolor", "64x64", "apps", "cura-icon.png"),
+        os.path.join("..", "icons", "cura-icon_128x128.png"): os.path.join("usr", "share", "icons", "hicolor", "128x128", "apps", "cura-icon.png"),
+        os.path.join("..", "icons", "cura-icon_256x256.png"): os.path.join("usr", "share", "icons", "hicolor", "256x256", "apps", "cura-icon.png"),
         os.path.join("..", "icons", "cura-icon_256x256.png"): "cura-icon.png",
         "cura.appdata.xml": "cura.appdata.xml",
         "AppRun": "AppRun"
@@ -37,8 +41,9 @@ def copy_metadata_files(dist_path, version):
 
     packaging_dir = os.path.dirname(__file__)
     for source, dest in copied_files.items():
-        print("Copying", os.path.join(packaging_dir, source), "to", os.path.join(dist_path, dest))
-        shutil.copyfile(os.path.join(packaging_dir, source), os.path.join(dist_path, dest))
+        dest_file_path = os.path.join(dist_path, dest)
+        os.makedirs(os.path.dirname(dest_file_path), exist_ok=True)
+        shutil.copyfile(os.path.join(packaging_dir, source), dest_file_path)
 
     # Ensure that AppRun has the proper permissions: 755 (user reads, writes and executes, group reads and executes, world reads and executes).
     print("Changing permissions for AppRun")

packaging/MacOS/build_macos.py

@@ -21,6 +21,7 @@ def build_dmg(source_path: str, dist_path: str, filename: str, app_name: str) ->
                  "--icon", app_name, "169", "272",
                  "--eula", f"{source_path}/packaging/cura_license.txt",
                  "--background", f"{source_path}/packaging/MacOs/cura_background_dmg.png",
+                 "--hdiutil-quiet",
                  f"{dist_path}/{filename}",
                  f"{dist_path}/{app_name}"]
 
@@ -138,18 +139,20 @@ def create_dmg(filename: str, dist_path: str, source_path: str, app_name: str) -
 
 if __name__ == "__main__":
     parser = argparse.ArgumentParser(description = "Create installer for Cura.")
-    parser.add_argument("source_path", type = str, help = "Path to Pyinstaller source folder")
-    parser.add_argument("dist_path", type = str, help = "Path to Pyinstaller dist folder")
-    parser.add_argument("cura_conan_version", type = str, help="The version of cura")
-    parser.add_argument("filename", type = str, help = "Filename of the pkg/dmg (e.g. 'UltiMaker-Cura-5.1.0-beta-Macos-X64.pkg' or 'UltiMaker-Cura-5.1.0-beta-Macos-X64.dmg')")
-    parser.add_argument("app_name", type = str, help = "Filename of the .app that will be contained within the dmg/pkg")
+    parser.add_argument("--source_path", required = True, type = str, help = "Path to Pyinstaller source folder")
+    parser.add_argument("--dist_path", required = True, type = str, help = "Path to Pyinstaller dist folder")
+    parser.add_argument("--cura_conan_version", required = True, type = str, help = "The version of cura")
+    parser.add_argument("--filename", required = True, type = str, help = "Filename of the pkg/dmg (e.g. 'UltiMaker-Cura-5.5.0-Macos-X64' or 'UltiMaker-Cura-5.5.0-beta.1-Macos-ARM64')")
+    parser.add_argument("--build_pkg", action="store_true", default = False, help = "build the pkg")
+    parser.add_argument("--build_dmg", action="store_true", default = True, help = "build the dmg")
+    parser.add_argument("--app_name", required = True, type = str, help = "Filename of the .app that will be contained within the dmg/pkg")
     args = parser.parse_args()
 
     cura_version = args.cura_conan_version.split("/")[-1]
 
     app_name = f"{args.app_name}.app"
 
-    if Path(args.filename).suffix == ".pkg":
-        create_pkg_installer(args.filename, args.dist_path, cura_version, app_name)
-    else:
-        create_dmg(args.filename, args.dist_path, args.source_path, app_name)
+    if args.build_pkg:
+        create_pkg_installer(f"{args.filename}.pkg", args.dist_path, cura_version, app_name)
+    if args.build_dmg:
+        create_dmg(f"{args.filename}.dmg", args.dist_path, args.source_path, app_name)

packaging/icons/cura-icon.svg

@@ -0,0 +1,36 @@
+<svg width="512" height="512" viewBox="0 0 512 512" fill="none" xmlns="http://www.w3.org/2000/svg">
+<g clip-path="url(#clip0_1923_105419)">
+<g filter="url(#filter0_i_1923_105419)">
+<path d="M461.002 364.531L364.531 461.002H51V147.471L147.471 51H461.002V364.531Z" fill="#196EF0"/>
+</g>
+<path d="M452 60V360.917L360.917 452H60V151.083L151.083 60H452Z" stroke="#FAFAFA" stroke-width="20"/>
+<g filter="url(#filter1_d_1923_105419)">
+<path fill-rule="evenodd" clip-rule="evenodd" d="M193.027 188.44C212.068 170.759 237.671 161 264.154 161H338V191H264.154C244.939 191 226.714 198.098 213.441 210.423C200.205 222.714 193 239.135 193 256C193 272.865 200.205 289.286 213.441 301.577C226.714 313.902 244.939 321 264.154 321H338V351H264.154C237.671 351 212.068 341.241 193.027 323.561C173.949 305.845 163 281.569 163 256C163 230.431 173.949 206.155 193.027 188.44Z" fill="#FAFAFA"/>
+</g>
+</g>
+<defs>
+<filter id="filter0_i_1923_105419" x="51" y="51" width="410.002" height="410.002" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB">
+<feFlood flood-opacity="0" result="BackgroundImageFix"/>
+<feBlend mode="normal" in="SourceGraphic" in2="BackgroundImageFix" result="shape"/>
+<feColorMatrix in="SourceAlpha" type="matrix" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 127 0" result="hardAlpha"/>
+<feOffset/>
+<feGaussianBlur stdDeviation="50"/>
+<feComposite in2="hardAlpha" operator="arithmetic" k2="-1" k3="1"/>
+<feColorMatrix type="matrix" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.5 0"/>
+<feBlend mode="normal" in2="shape" result="effect1_innerShadow_1923_105419"/>
+</filter>
+<filter id="filter1_d_1923_105419" x="123" y="121" width="255" height="270" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB">
+<feFlood flood-opacity="0" result="BackgroundImageFix"/>
+<feColorMatrix in="SourceAlpha" type="matrix" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 127 0" result="hardAlpha"/>
+<feOffset/>
+<feGaussianBlur stdDeviation="20"/>
+<feComposite in2="hardAlpha" operator="out"/>
+<feColorMatrix type="matrix" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.4 0"/>
+<feBlend mode="normal" in2="BackgroundImageFix" result="effect1_dropShadow_1923_105419"/>
+<feBlend mode="normal" in="SourceGraphic" in2="effect1_dropShadow_1923_105419" result="shape"/>
+</filter>
+<clipPath id="clip0_1923_105419">
+<rect width="512" height="512" fill="white"/>
+</clipPath>
+</defs>
+</svg>

packaging/msi/ExcludeComponents.xslt

@@ -20,10 +20,15 @@
     ...but we can use this longer `substring` expression instead (see https://github.com/wixtoolset/issues/issues/5609 )
     -->
     <xsl:key
-            name="ExeToRemove"
-            match="wix:Component[ substring( wix:File/@Source, string-length( wix:File/@Source ) - 3 ) = '.exe' ]"
+            name="UltiMaker_Cura_exe_ToRemove"
+            match="wix:Component[ substring( wix:File/@Source, string-length( wix:File/@Source ) - 17 ) = 'UltiMaker-Cura.exe' ]"
             use="@Id"
-    /> <!-- Get the last 4 characters of a string using `substring( s, len(s) - 3 )`, it uses -3 and not -4 because XSLT uses 1-based indexes, not 0-based indexes. -->
+    />
+    <xsl:key
+            name="CuraEngine_exe_ToRemove"
+            match="wix:Component[ substring( wix:File/@Source, string-length( wix:File/@Source ) - 17 ) = 'CuraEngine.exe' ]"
+            use="@Id"
+    />
 
     <!-- By default, copy all elements and nodes into the output... -->
     <xsl:template match="@*|node()">
@@ -32,6 +37,7 @@
         </xsl:copy>
     </xsl:template>
 
-    <!-- ...but if the element has the "ExeToRemove" key then don't render anything (i.e. removing it from the output) -->
-    <xsl:template match="*[ self::wix:Component or self::wix:ComponentRef ][ key( 'ExeToRemove', @Id ) ]"/>
+    <!-- ...but if the element has the "UltiMaker_Cura_exe_ToRemove" or "CuraEngine_exe_ToRemove" key then don't render anything (i.e. removing it from the output) -->
+    <xsl:template match="*[ self::wix:Component or self::wix:ComponentRef ][ key( 'UltiMaker_Cura_exe_ToRemove', @Id ) ]"/>
+    <xsl:template match="*[ self::wix:Component or self::wix:ComponentRef ][ key( 'CuraEngine_exe_ToRemove', @Id ) ]"/>
 </xsl:stylesheet>

plugins/3MFReader/ThreeMFReader.py

@@ -56,7 +56,8 @@ class ThreeMFReader(MeshReader):
     def emptyFileHintSet(self) -> bool:
         return self._empty_project
 
-    def _createMatrixFromTransformationString(self, transformation: str) -> Matrix:
+    @staticmethod
+    def _createMatrixFromTransformationString(transformation: str) -> Matrix:
         if transformation == "":
             return Matrix()
 
@@ -90,7 +91,8 @@ class ThreeMFReader(MeshReader):
 
         return temp_mat
 
-    def _convertSavitarNodeToUMNode(self, savitar_node: Savitar.SceneNode, file_name: str = "") -> Optional[SceneNode]:
+    @staticmethod
+    def _convertSavitarNodeToUMNode(savitar_node: Savitar.SceneNode, file_name: str = "") -> Optional[SceneNode]:
         """Convenience function that converts a SceneNode object (as obtained from libSavitar) to a scene node.
 
         :returns: Scene node.
@@ -119,7 +121,7 @@ class ThreeMFReader(MeshReader):
             pass
         um_node.setName(node_name)
         um_node.setId(node_id)
-        transformation = self._createMatrixFromTransformationString(savitar_node.getTransformation())
+        transformation = ThreeMFReader._createMatrixFromTransformationString(savitar_node.getTransformation())
         um_node.setTransformation(transformation)
         mesh_builder = MeshBuilder()
 
@@ -138,7 +140,7 @@ class ThreeMFReader(MeshReader):
             um_node.setMeshData(mesh_data)
 
         for child in savitar_node.getChildren():
-            child_node = self._convertSavitarNodeToUMNode(child)
+            child_node = ThreeMFReader._convertSavitarNodeToUMNode(child)
             if child_node:
                 um_node.addChild(child_node)
 
@@ -214,7 +216,7 @@ class ThreeMFReader(MeshReader):
                 CuraApplication.getInstance().getController().getScene().setMetaDataEntry(key, value)
 
             for node in scene_3mf.getSceneNodes():
-                um_node = self._convertSavitarNodeToUMNode(node, file_name)
+                um_node = ThreeMFReader._convertSavitarNodeToUMNode(node, file_name)
                 if um_node is None:
                     continue
 
@@ -300,8 +302,23 @@ class ThreeMFReader(MeshReader):
         if unit is None:
             unit = "millimeter"
         elif unit not in conversion_to_mm:
-            Logger.log("w", "Unrecognised unit {unit} used. Assuming mm instead.".format(unit = unit))
+            Logger.log("w", "Unrecognised unit {unit} used. Assuming mm instead.".format(unit=unit))
             unit = "millimeter"
 
         scale = conversion_to_mm[unit]
         return Vector(scale, scale, scale)
+
+    @staticmethod
+    def stringToSceneNodes(scene_string: str) -> List[SceneNode]:
+        parser = Savitar.ThreeMFParser()
+        scene = parser.parse(scene_string)
+
+        # Convert the scene to scene nodes
+        nodes = []
+        for savitar_node in scene.getSceneNodes():
+            scene_node = ThreeMFReader._convertSavitarNodeToUMNode(savitar_node, "file_name")
+            if scene_node is None:
+                continue
+            nodes.append(scene_node)
+
+        return nodes

plugins/3MFReader/ThreeMFWorkspaceReader.py

@@ -43,7 +43,7 @@ from .WorkspaceDialog import WorkspaceDialog
 i18n_catalog = i18nCatalog("cura")
 
 
-_ignored_machine_network_metadata = {
+_ignored_machine_network_metadata: Set[str] = {
     "um_cloud_cluster_id",
     "um_network_key",
     "um_linked_to_account",
@@ -55,7 +55,7 @@ _ignored_machine_network_metadata = {
     "capabilities",
     "octoprint_api_key",
     "is_abstract_machine"
-}  # type: Set[str]
+}
 
 
 class ContainerInfo:
@@ -69,41 +69,41 @@ class ContainerInfo:
 
 class QualityChangesInfo:
     def __init__(self) -> None:
-        self.name = None
+        self.name: Optional[str] = None
         self.global_info = None
-        self.extruder_info_dict = {} # type: Dict[str, ContainerInfo]
+        self.extruder_info_dict: Dict[str, ContainerInfo] = {}
 
 
 class MachineInfo:
     def __init__(self) -> None:
-        self.container_id = None
-        self.name = None
-        self.definition_id = None
+        self.container_id: Optional[str] = None
+        self.name: Optional[str] = None
+        self.definition_id: Optional[str] = None
 
-        self.metadata_dict = {}  # type: Dict[str, str]
+        self.metadata_dict: Dict[str, str] = {}
 
-        self.quality_type = None
-        self.intent_category = None
-        self.custom_quality_name = None
-        self.quality_changes_info = None
-        self.variant_info = None
+        self.quality_type: Optional[str] = None
+        self.intent_category: Optional[str] = None
+        self.custom_quality_name: Optional[str] = None
+        self.quality_changes_info: Optional[QualityChangesInfo] = None
+        self.variant_info: Optional[ContainerInfo] = None
 
-        self.definition_changes_info = None
-        self.user_changes_info = None
+        self.definition_changes_info: Optional[ContainerInfo] = None
+        self.user_changes_info: Optional[ContainerInfo] = None
 
-        self.extruder_info_dict = {} # type: Dict[str, ExtruderInfo]
+        self.extruder_info_dict: Dict[str, str] = {}
 
 
 class ExtruderInfo:
     def __init__(self) -> None:
         self.position = None
         self.enabled = True
-        self.variant_info = None
-        self.root_material_id = None
+        self.variant_info: Optional[ContainerInfo] = None
+        self.root_material_id: Optional[str] = None
 
-        self.definition_changes_info = None
-        self.user_changes_info = None
-        self.intent_info = None
+        self.definition_changes_info: Optional[ContainerInfo] = None
+        self.user_changes_info: Optional[ContainerInfo] = None
+        self.intent_info: Optional[ContainerInfo] = None
 
 
 class ThreeMFWorkspaceReader(WorkspaceReader):
@@ -131,14 +131,14 @@ class ThreeMFWorkspaceReader(WorkspaceReader):
         #  - variant
         self._ignored_instance_container_types = {"quality", "variant"}
 
-        self._resolve_strategies = {} # type: Dict[str, str]
+        self._resolve_strategies: Dict[str, str] = {}
 
-        self._id_mapping = {} # type: Dict[str, str]
+        self._id_mapping: Dict[str, str] = {}
 
         # In Cura 2.5 and 2.6, the empty profiles used to have those long names
         self._old_empty_profile_id_dict = {"empty_%s" % k: "empty" for k in ["material", "variant"]}
 
-        self._old_new_materials = {} # type: Dict[str, str]
+        self._old_new_materials: Dict[str, str] = {}
         self._machine_info = None
 
     def _clearState(self):
@@ -461,11 +461,15 @@ class ThreeMFWorkspaceReader(WorkspaceReader):
 
         materials_in_extruders_dict = {}  # Which material is in which extruder
 
-        # if the global stack is found, we check if there are conflicts in the extruder stacks
+        # If the global stack is found, we check if there are conflicts in the extruder stacks
         for extruder_stack_file in extruder_stack_files:
             serialized = archive.open(extruder_stack_file).read().decode("utf-8")
+
+            not_upgraded_parser = ConfigParser(interpolation=None)
+            not_upgraded_parser.read_string(serialized)
+
             serialized = ExtruderStack._updateSerialized(serialized, extruder_stack_file)
-            parser = ConfigParser(interpolation = None)
+            parser = ConfigParser(interpolation=None)
             parser.read_string(serialized)
 
             # The check should be done for the extruder stack that's associated with the existing global stack,
@@ -497,19 +501,26 @@ class ThreeMFWorkspaceReader(WorkspaceReader):
                 extruder_info.user_changes_info = instance_container_info_dict[user_changes_id]
             self._machine_info.extruder_info_dict[position] = extruder_info
 
+            intent_container_id = parser["containers"][str(_ContainerIndexes.Intent)]
+
             intent_id = parser["containers"][str(_ContainerIndexes.Intent)]
             if intent_id not in ("empty", "empty_intent"):
-                extruder_info.intent_info = instance_container_info_dict[intent_id]
+                if intent_container_id in instance_container_info_dict:
+                    extruder_info.intent_info = instance_container_info_dict[intent_id]
+                else:
+                    # It can happen that an intent has been renamed. In that case, we should still use the old
+                    # name, since we used that to generate the instance_container_info_dict keys. 
+                    extruder_info.intent_info = instance_container_info_dict[not_upgraded_parser["containers"][str(_ContainerIndexes.Intent)]]
 
             if not machine_conflict and containers_found_dict["machine"] and global_stack:
                 if int(position) >= len(global_stack.extruderList):
                     continue
 
                 existing_extruder_stack = global_stack.extruderList[int(position)]
-                # check if there are any changes at all in any of the container stacks.
+                # Check if there are any changes at all in any of the container stacks.
                 id_list = self._getContainerIdListFromSerialized(serialized)
                 for index, container_id in enumerate(id_list):
-                    # take into account the old empty container IDs
+                    # Take into account the old empty container IDs
                     container_id = self._old_empty_profile_id_dict.get(container_id, container_id)
                     if existing_extruder_stack.getContainer(index).getId() != container_id:
                         machine_conflict = True
@@ -740,7 +751,7 @@ class ThreeMFWorkspaceReader(WorkspaceReader):
             # quality_changes file. If that's the case, take the extruder count into account when creating the machine
             # or else the extruderList will return only the first extruder, leading to missing non-global settings in
             # the other extruders.
-            machine_extruder_count = self._getMachineExtruderCount()  # type: Optional[int]
+            machine_extruder_count: Optional[int] = self._getMachineExtruderCount()
             global_stack = CuraStackBuilder.createMachine(machine_name, self._machine_info.definition_id, machine_extruder_count)
             if global_stack:  # Only switch if creating the machine was successful.
                 extruder_stack_dict = {str(position): extruder for position, extruder in enumerate(global_stack.extruderList)}
@@ -751,8 +762,7 @@ class ThreeMFWorkspaceReader(WorkspaceReader):
             global_stacks = self._container_registry.findContainerStacks(id = self._dialog.getMachineToOverride(), type = "machine")
             if not global_stacks:
                 message = Message(i18n_catalog.i18nc("@info:error Don't translate the XML tag <filename>!", 
-                                                     "Project file <filename>{0}</filename> is made using profiles that"
-                                                     " are unknown to this version of Ultimaker Cura.", file_name),
+                                                     "Project file <filename>{0}</filename> is made using profiles that are unknown to this version of UltiMaker Cura.", file_name),
                                                      message_type = Message.MessageType.ERROR)
                 message.show()
                 self.setWorkspaceName("")
@@ -868,7 +878,7 @@ class ThreeMFWorkspaceReader(WorkspaceReader):
 
     @staticmethod
     def _loadMetadata(file_name: str) -> Dict[str, Dict[str, Any]]:
-        result = dict()  # type: Dict[str, Dict[str, Any]]
+        result: Dict[str, Dict[str, Any]] = dict()
         try:
             archive = zipfile.ZipFile(file_name, "r")
         except zipfile.BadZipFile:
@@ -880,7 +890,6 @@ class ThreeMFWorkspaceReader(WorkspaceReader):
 
         metadata_files = [name for name in archive.namelist() if name.endswith("plugin_metadata.json")]
 
-
         for metadata_file in metadata_files:
             try:
                 plugin_id = metadata_file.split("/")[0]
@@ -921,7 +930,7 @@ class ThreeMFWorkspaceReader(WorkspaceReader):
                 quality_changes_name = self._container_registry.uniqueName(quality_changes_name)
                 for position, container_info in container_info_dict.items():
                     extruder_stack = None
-                    intent_category = None  # type: Optional[str]
+                    intent_category: Optional[str] = None
                     if position is not None:
                         try:
                             extruder_stack = global_stack.extruderList[int(position)]
@@ -1086,7 +1095,8 @@ class ThreeMFWorkspaceReader(WorkspaceReader):
                 if global_stack.getProperty(key, "settable_per_extruder"):
                     values_to_set_for_extruders[key] = value
                 else:
-                    global_stack.definitionChanges.setProperty(key, "value", value)
+                    if not self._settingIsFromMissingPackage(key, value):
+                        global_stack.definitionChanges.setProperty(key, "value", value)
 
         for position, extruder_stack in extruder_stack_dict.items():
             if position not in self._machine_info.extruder_info_dict:
@@ -1100,7 +1110,8 @@ class ThreeMFWorkspaceReader(WorkspaceReader):
                 extruder_stack.definitionChanges.setProperty(key, "value", value)
             if parser is not None:
                 for key, value in parser["values"].items():
-                    extruder_stack.definitionChanges.setProperty(key, "value", value)
+                    if not self._settingIsFromMissingPackage(key, value):
+                        extruder_stack.definitionChanges.setProperty(key, "value", value)
 
     def _applyUserChanges(self, global_stack, extruder_stack_dict):
         values_to_set_for_extruder_0 = {}
@@ -1110,7 +1121,8 @@ class ThreeMFWorkspaceReader(WorkspaceReader):
                 if global_stack.getProperty(key, "settable_per_extruder"):
                     values_to_set_for_extruder_0[key] = value
                 else:
-                    global_stack.userChanges.setProperty(key, "value", value)
+                    if not self._settingIsFromMissingPackage(key, value):
+                        global_stack.userChanges.setProperty(key, "value", value)
 
         for position, extruder_stack in extruder_stack_dict.items():
             if position not in self._machine_info.extruder_info_dict:
@@ -1124,7 +1136,8 @@ class ThreeMFWorkspaceReader(WorkspaceReader):
                         extruder_stack.userChanges.setProperty(key, "value", value)
                 if parser is not None:
                     for key, value in parser["values"].items():
-                        extruder_stack.userChanges.setProperty(key, "value", value)
+                        if not self._settingIsFromMissingPackage(key, value):
+                            extruder_stack.userChanges.setProperty(key, "value", value)
 
     def _applyVariants(self, global_stack, extruder_stack_dict):
         machine_node = ContainerTree.getInstance().machines[global_stack.definition.getId()]
@@ -1162,7 +1175,7 @@ class ThreeMFWorkspaceReader(WorkspaceReader):
             root_material_id = self._old_new_materials.get(root_material_id, root_material_id)
 
             material_node = machine_node.variants[extruder_stack.variant.getName()].materials[root_material_id]
-            extruder_stack.material = material_node.container  # type: InstanceContainer
+            extruder_stack.material = material_node.container
 
     def _applyChangesToMachine(self, global_stack, extruder_stack_dict):
         # Clear all first
@@ -1199,6 +1212,15 @@ class ThreeMFWorkspaceReader(WorkspaceReader):
             if key not in _ignored_machine_network_metadata:
                 global_stack.setMetaDataEntry(key, value)
 
+    def _settingIsFromMissingPackage(self, key, value):
+        # Check if the key and value pair is from the missing package
+        for package in self._dialog.missingPackages:
+            if value.startswith("PLUGIN::"):
+                if (package['id'] + "@" + package['package_version']) in value:
+                    Logger.log("w", f"Ignoring {key} value {value} from missing package")
+                    return True
+        return False
+
     def _updateActiveMachine(self, global_stack):
         # Actually change the active machine.
         machine_manager = Application.getInstance().getMachineManager()
@@ -1318,3 +1340,4 @@ class ThreeMFWorkspaceReader(WorkspaceReader):
                 missing_packages.append(package)
 
         return missing_packages
+

plugins/3MFReader/WorkspaceDialog.py

@@ -408,26 +408,27 @@ class WorkspaceDialog(QObject):
     @pyqtSlot()
     def showMissingMaterialsWarning(self) -> None:
         result_message = Message(
-            i18n_catalog.i18nc("@info:status", "The material used in this project relies on some material definitions not available in Cura, this might produce undesirable print results. We highly recommend installing the full material package from the Marketplace."),
+            i18n_catalog.i18nc("@info:status",
+                               "Some of the packages used in the project file are currently not installed in Cura, this might produce undesirable print results. We highly recommend installing the all required packages from the Marketplace."),
             lifetime=0,
-            title=i18n_catalog.i18nc("@info:title", "Material profiles not installed"),
+            title=i18n_catalog.i18nc("@info:title", "Some required packages are not installed"),
             message_type=Message.MessageType.WARNING
         )
         result_message.addAction(
-                "learn_more",
-                name=i18n_catalog.i18nc("@action:button", "Learn more"),
-                icon="",
-                description="Learn more about project materials.",
-                button_align=Message.ActionButtonAlignment.ALIGN_LEFT,
-                button_style=Message.ActionButtonStyle.LINK
+            "learn_more",
+            name=i18n_catalog.i18nc("@action:button", "Learn more"),
+            icon="",
+            description=i18n_catalog.i18nc("@label", "Learn more about project packages."),
+            button_align=Message.ActionButtonAlignment.ALIGN_LEFT,
+            button_style=Message.ActionButtonStyle.LINK
         )
         result_message.addAction(
-                "install_materials",
-                name=i18n_catalog.i18nc("@action:button", "Install Materials"),
-                icon="",
-                description="Install missing materials from project file.",
-                button_align=Message.ActionButtonAlignment.ALIGN_RIGHT,
-                button_style=Message.ActionButtonStyle.DEFAULT
+            "install_packages",
+            name=i18n_catalog.i18nc("@action:button", "Install Packages"),
+            icon="",
+            description=i18n_catalog.i18nc("@label", "Install missing packages from project file."),
+            button_align=Message.ActionButtonAlignment.ALIGN_RIGHT,
+            button_style=Message.ActionButtonStyle.DEFAULT
         )
         result_message.actionTriggered.connect(self._onMessageActionTriggered)
         result_message.show()

plugins/3MFReader/WorkspaceDialog.qml

@@ -364,7 +364,7 @@ UM.Dialog
                 UM.Label
                 {
                     id: warningText
-                    text: catalog.i18nc("@label", "The material used in this project is currently not installed in Cura.<br/>Install the material profile and reopen the project.")
+                    text: catalog.i18nc("@label", "This project contains materials or plugins that are currently not installed in Cura.<br/>Install the missing packages and reopen the project.")
                 }
             }
 
@@ -404,7 +404,7 @@ UM.Dialog
         Cura.PrimaryButton
         {
             visible: warning
-            text: catalog.i18nc("@action:button", "Install missing material")
+            text: catalog.i18nc("@action:button", "Install missing packages")
             onClicked: manager.installMissingPackages()
         }
     ]

plugins/3MFWriter/ThreeMFWorkspaceWriter.py

@@ -40,7 +40,9 @@ class ThreeMFWorkspaceWriter(WorkspaceWriter):
 
         # Indicate that the 3mf mesh writer should not close the archive just yet (we still need to add stuff to it).
         mesh_writer.setStoreArchive(True)
-        mesh_writer.write(stream, nodes, mode)
+        if not mesh_writer.write(stream, nodes, mode):
+            self.setInformation(mesh_writer.getInformation())
+            return False
 
         archive = mesh_writer.getArchive()
         if archive is None:  # This happens if there was no mesh data to write.
@@ -98,7 +100,7 @@ class ThreeMFWorkspaceWriter(WorkspaceWriter):
             Logger.error("No permission to write workspace to this stream.")
             return False
         except EnvironmentError as e:
-            self.setInformation(catalog.i18nc("@error:zip", "The operating system does not allow saving a project file to this location or with this file name."))
+            self.setInformation(catalog.i18nc("@error:zip", str(e)))
             Logger.error("EnvironmentError when writing workspace to this stream: {err}".format(err = str(e)))
             return False
         mesh_writer.setStoreArchive(False)

plugins/3MFWriter/ThreeMFWriter.py

@@ -1,8 +1,9 @@
 #  Copyright (c) 2015-2022 Ultimaker B.V.
 #  Cura is released under the terms of the LGPLv3 or higher.
 import json
+import re
 
-from typing import Optional, cast, List, Dict
+from typing import Optional, cast, List, Dict, Pattern, Set
 
 from UM.Mesh.MeshWriter import MeshWriter
 from UM.Math.Vector import Vector
@@ -17,6 +18,7 @@ from UM.Settings.EmptyInstanceContainer import EmptyInstanceContainer
 
 from cura.CuraApplication import CuraApplication
 from cura.CuraPackageManager import CuraPackageManager
+from cura.Settings import CuraContainerStack
 from cura.Utils.Threading import call_on_qt_thread
 from cura.Snapshot import Snapshot
 
@@ -55,11 +57,12 @@ class ThreeMFWriter(MeshWriter):
             "cura": "http://software.ultimaker.com/xml/cura/3mf/2015/10"
         }
 
-        self._unit_matrix_string = self._convertMatrixToString(Matrix())
+        self._unit_matrix_string = ThreeMFWriter._convertMatrixToString(Matrix())
         self._archive: Optional[zipfile.ZipFile] = None
         self._store_archive = False
 
-    def _convertMatrixToString(self, matrix):
+    @staticmethod
+    def _convertMatrixToString(matrix):
         result = ""
         result += str(matrix._data[0, 0]) + " "
         result += str(matrix._data[1, 0]) + " "
@@ -83,7 +86,8 @@ class ThreeMFWriter(MeshWriter):
         """
         self._store_archive = store_archive
 
-    def _convertUMNodeToSavitarNode(self, um_node, transformation = Matrix()):
+    @staticmethod
+    def _convertUMNodeToSavitarNode(um_node, transformation=Matrix()):
         """Convenience function that converts an Uranium SceneNode object to a SavitarSceneNode
 
         :returns: Uranium Scene node.
@@ -100,7 +104,7 @@ class ThreeMFWriter(MeshWriter):
 
         node_matrix = um_node.getLocalTransformation()
 
-        matrix_string = self._convertMatrixToString(node_matrix.preMultiply(transformation))
+        matrix_string = ThreeMFWriter._convertMatrixToString(node_matrix.preMultiply(transformation))
 
         savitar_node.setTransformation(matrix_string)
         mesh_data = um_node.getMeshData()
@@ -133,7 +137,7 @@ class ThreeMFWriter(MeshWriter):
             # only save the nodes on the active build plate
             if child_node.callDecoration("getBuildPlateNumber") != active_build_plate_nr:
                 continue
-            savitar_child_node = self._convertUMNodeToSavitarNode(child_node)
+            savitar_child_node = ThreeMFWriter._convertUMNodeToSavitarNode(child_node)
             if savitar_child_node is not None:
                 savitar_node.addChild(savitar_child_node)
 
@@ -175,13 +179,15 @@ class ThreeMFWriter(MeshWriter):
                 archive.writestr(thumbnail_file, thumbnail_buffer.data())
 
                 # Add PNG to content types file
-                thumbnail_type = ET.SubElement(content_types, "Default", Extension = "png", ContentType = "image/png")
+                thumbnail_type = ET.SubElement(content_types, "Default", Extension="png", ContentType="image/png")
                 # Add thumbnail relation to _rels/.rels file
-                thumbnail_relation_element = ET.SubElement(relations_element, "Relationship", Target = "/" + THUMBNAIL_PATH, Id = "rel1", Type = "http://schemas.openxmlformats.org/package/2006/relationships/metadata/thumbnail")
+                thumbnail_relation_element = ET.SubElement(relations_element, "Relationship",
+                                                           Target="/" + THUMBNAIL_PATH, Id="rel1",
+                                                           Type="http://schemas.openxmlformats.org/package/2006/relationships/metadata/thumbnail")
 
             # Write material metadata
-            material_metadata = self._getMaterialPackageMetadata()
-            self._storeMetadataJson({"packages": material_metadata}, archive, PACKAGE_METADATA_PATH)
+            packages_metadata = self._getMaterialPackageMetadata() + self._getPluginPackageMetadata()
+            self._storeMetadataJson({"packages": packages_metadata}, archive, PACKAGE_METADATA_PATH)
 
             savitar_scene = Savitar.Scene()
 
@@ -221,7 +227,7 @@ class ThreeMFWriter(MeshWriter):
             for node in nodes:
                 if node == root_node:
                     for root_child in node.getChildren():
-                        savitar_node = self._convertUMNodeToSavitarNode(root_child, transformation_matrix)
+                        savitar_node = ThreeMFWriter._convertUMNodeToSavitarNode(root_child, transformation_matrix)
                         if savitar_node:
                             savitar_scene.addSceneNode(savitar_node)
                 else:
@@ -235,9 +241,9 @@ class ThreeMFWriter(MeshWriter):
             archive.writestr(model_file, scene_string)
             archive.writestr(content_types_file, b'<?xml version="1.0" encoding="UTF-8"?> \n' + ET.tostring(content_types))
             archive.writestr(relations_file, b'<?xml version="1.0" encoding="UTF-8"?> \n' + ET.tostring(relations_element))
-        except Exception as e:
+        except Exception as error:
             Logger.logException("e", "Error writing zip file")
-            self.setInformation(catalog.i18nc("@error:zip", "Error writing 3mf file."))
+            self.setInformation(str(error))
             return False
         finally:
             if not self._store_archive:
@@ -253,7 +259,64 @@ class ThreeMFWriter(MeshWriter):
         metadata_file = zipfile.ZipInfo(path)
         # We have to set the compress type of each file as well (it doesn't keep the type of the entire archive)
         metadata_file.compress_type = zipfile.ZIP_DEFLATED
-        archive.writestr(metadata_file, json.dumps(metadata, separators=(", ", ": "), indent=4, skipkeys=True, ensure_ascii=False))
+        archive.writestr(metadata_file,
+                         json.dumps(metadata, separators=(", ", ": "), indent=4, skipkeys=True, ensure_ascii=False))
+
+    @staticmethod
+    def _getPluginPackageMetadata() -> List[Dict[str, str]]:
+        """Get metadata for all backend plugins that are used in the project.
+
+        :return: List of material metadata dictionaries.
+        """
+
+        backend_plugin_enum_value_regex = re.compile(
+            r"PLUGIN::(?P<plugin_id>\w+)@(?P<version>\d+.\d+.\d+)::(?P<value>\w+)")
+        # This regex parses enum values to find if they contain custom
+        # backend engine values. These custom enum values are in the format
+        #      PLUGIN::<plugin_id>@<version>::<value>
+        # where
+        #  - plugin_id is the id of the plugin
+        #  - version is in the semver format
+        #  - value is the value of the enum
+
+        plugin_ids = set()
+
+        def addPluginIdsInStack(stack: CuraContainerStack) -> None:
+            for key in stack.getAllKeys():
+                value = str(stack.getProperty(key, "value"))
+                for plugin_id, _version, _value in backend_plugin_enum_value_regex.findall(value):
+                    plugin_ids.add(plugin_id)
+
+        # Go through all stacks and find all the plugin id contained in the project
+        global_stack = CuraApplication.getInstance().getMachineManager().activeMachine
+        addPluginIdsInStack(global_stack)
+
+        for container in global_stack.getContainers():
+            addPluginIdsInStack(container)
+
+        for extruder_stack in global_stack.extruderList:
+            addPluginIdsInStack(extruder_stack)
+
+            for container in extruder_stack.getContainers():
+                addPluginIdsInStack(container)
+
+        metadata = {}
+
+        package_manager = cast(CuraPackageManager, CuraApplication.getInstance().getPackageManager())
+        for plugin_id in plugin_ids:
+            package_data = package_manager.getInstalledPackageInfo(plugin_id)
+
+            metadata[plugin_id] = {
+                "id": plugin_id,
+                "display_name": package_data.get("display_name") if package_data.get("display_name") else "",
+                "package_version": package_data.get("package_version") if package_data.get("package_version") else "",
+                "sdk_version_semver": package_data.get("sdk_version_semver") if package_data.get(
+                    "sdk_version_semver") else "",
+                "type": "plugin",
+            }
+
+        # Storing in a dict and fetching values to avoid duplicates
+        return list(metadata.values())
 
     @staticmethod
     def _getMaterialPackageMetadata() -> List[Dict[str, str]]:
@@ -278,7 +341,8 @@ class ThreeMFWriter(MeshWriter):
                 # Don't export bundled materials
                 continue
 
-            package_id = package_manager.getMaterialFilePackageId(extruder.material.getFileName(), extruder.material.getMetaDataEntry("GUID"))
+            package_id = package_manager.getMaterialFilePackageId(extruder.material.getFileName(),
+                                                                  extruder.material.getMetaDataEntry("GUID"))
             package_data = package_manager.getInstalledPackageInfo(package_id)
 
             # We failed to find the package for this material
@@ -286,10 +350,14 @@ class ThreeMFWriter(MeshWriter):
                 Logger.info(f"Could not find package for material in extruder {extruder.id}, skipping.")
                 continue
 
-            material_metadata = {"id": package_id,
-                                 "display_name": package_data.get("display_name") if package_data.get("display_name") else "",
-                                 "package_version": package_data.get("package_version") if package_data.get("package_version") else "",
-                                 "sdk_version_semver": package_data.get("sdk_version_semver") if package_data.get("sdk_version_semver") else ""}
+            material_metadata = {
+                "id": package_id,
+                "display_name": package_data.get("display_name") if package_data.get("display_name") else "",
+                "package_version": package_data.get("package_version") if package_data.get("package_version") else "",
+                "sdk_version_semver": package_data.get("sdk_version_semver") if package_data.get(
+                    "sdk_version_semver") else "",
+                "type": "material",
+            }
 
             metadata[package_id] = material_metadata
 
@@ -303,9 +371,19 @@ class ThreeMFWriter(MeshWriter):
             Logger.log("w", "Can't create snapshot when renderer not initialized.")
             return None
         try:
-            snapshot = Snapshot.snapshot(width = 300, height = 300)
+            snapshot = Snapshot.snapshot(width=300, height=300)
         except:
             Logger.logException("w", "Failed to create snapshot image")
             return None
 
         return snapshot
+
+    @staticmethod
+    def sceneNodesToString(scene_nodes: [SceneNode]) -> str:
+        savitar_scene = Savitar.Scene()
+        for scene_node in scene_nodes:
+            savitar_node = ThreeMFWriter._convertUMNodeToSavitarNode(scene_node)
+            savitar_scene.addSceneNode(savitar_node)
+        parser = Savitar.ThreeMFParser()
+        scene_string = parser.sceneToString(savitar_scene)
+        return scene_string

plugins/3MFWriter/tests/TestMFWriter.py

@@ -0,0 +1,60 @@
+import sys
+import os.path
+from typing import Dict, Optional
+import pytest
+
+from unittest.mock import patch, MagicMock, PropertyMock
+
+from UM.PackageManager import PackageManager
+from cura.CuraApplication import CuraApplication
+
+sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), ".."))
+
+import ThreeMFWriter
+
+PLUGIN_ID = "my_plugin"
+DISPLAY_NAME = "MyPlugin"
+PACKAGE_VERSION = "0.0.1"
+SDK_VERSION = "8.0.0"
+
+
+@pytest.fixture
+def package_manager() -> MagicMock:
+    pm = MagicMock(spec=PackageManager)
+    pm.getInstalledPackageInfo.return_value = {
+        "display_name": DISPLAY_NAME,
+        "package_version": PACKAGE_VERSION,
+        "sdk_version_semver": SDK_VERSION
+    }
+    return pm
+
+
+@pytest.fixture
+def machine_manager() -> MagicMock:
+    mm = MagicMock(spec=PackageManager)
+    active_machine = MagicMock()
+    active_machine.getAllKeys.return_value = ["infill_pattern", "layer_height", "material_bed_temperature"]
+    active_machine.getProperty.return_value = f"PLUGIN::{PLUGIN_ID}@{PACKAGE_VERSION}::custom_value"
+    active_machine.getContainers.return_value = []
+    active_machine.extruderList = []
+    mm.activeMachine = active_machine
+    return mm
+
+
+@pytest.fixture
+def application(package_manager, machine_manager):
+    app = MagicMock()
+    app.getPackageManager.return_value = package_manager
+    app.getMachineManager.return_value = machine_manager
+    return app
+
+
+def test_enumParsing(application):
+    with patch("cura.CuraApplication.CuraApplication.getInstance", MagicMock(return_value=application)):
+        packages_metadata = ThreeMFWriter.ThreeMFWriter._getPluginPackageMetadata()[0]
+
+        assert packages_metadata.get("id") == PLUGIN_ID
+        assert packages_metadata.get("display_name") == DISPLAY_NAME
+        assert packages_metadata.get("package_version") == PACKAGE_VERSION
+        assert packages_metadata.get("sdk_version_semver") == SDK_VERSION
+        assert packages_metadata.get("type") == "plugin"

plugins/CuraEngineBackend/Cura.proto

@@ -8,12 +8,31 @@ message ObjectList
     repeated Setting settings = 2; // meshgroup settings (for one-at-a-time printing)
 }
 
+enum SlotID {
+  SETTINGS_BROADCAST = 0;
+  SIMPLIFY_MODIFY = 100;
+  POSTPROCESS_MODIFY = 101;
+  INFILL_MODIFY = 102;
+  GCODE_PATHS_MODIFY = 103;
+  INFILL_GENERATE = 200;
+}
+
+message EnginePlugin
+{
+    SlotID id = 1;
+    string address = 2;
+    uint32 port = 3;
+    string plugin_name = 4;
+    string plugin_version = 5;
+}
+
 message Slice
 {
     repeated ObjectList object_lists = 1; // The meshgroups to be printed one after another
     SettingList global_settings = 2; // The global settings used for the whole print job
     repeated Extruder extruders = 3; // The settings sent to each extruder object
     repeated SettingExtruder limit_to_extruder = 4; // From which stack the setting would inherit if not defined per object
+    repeated EnginePlugin engine_plugins = 5;
 }
 
 message Extruder

plugins/CuraEngineBackend/CuraEngineBackend.py

@@ -46,6 +46,19 @@ catalog = i18nCatalog("cura")
 class CuraEngineBackend(QObject, Backend):
     backendError = Signal()
 
+    printDurationMessage = Signal()
+    """Emitted when we get a message containing print duration and material amount.
+
+    This also implies the slicing has finished.
+    :param time: The amount of time the print will take.
+    :param material_amount: The amount of material the print will use.
+    """
+    slicingStarted = Signal()
+    """Emitted when the slicing process starts."""
+
+    slicingCancelled = Signal()
+    """Emitted when the slicing process is aborted forcefully."""
+
     def __init__(self) -> None:
         """Starts the back-end plug-in.
 
@@ -70,7 +83,6 @@ class CuraEngineBackend(QObject, Backend):
             os.path.join(CuraApplication.getInstallPrefix(), "bin"),
             os.path.dirname(os.path.abspath(sys.executable)),
         ]
-
         for path in search_path:
             engine_path = os.path.join(path, executable_name)
             if os.path.isfile(engine_path):
@@ -86,9 +98,9 @@ class CuraEngineBackend(QObject, Backend):
                     self._default_engine_location = execpath
                     break
 
-        application = CuraApplication.getInstance() #type: CuraApplication
-        self._multi_build_plate_model = None #type: Optional[MultiBuildPlateModel]
-        self._machine_error_checker = None #type: Optional[MachineErrorChecker]
+        application: CuraApplication = CuraApplication.getInstance()
+        self._multi_build_plate_model: Optional[MultiBuildPlateModel] = None
+        self._machine_error_checker: Optional[MachineErrorChecker] = None
 
         if not self._default_engine_location:
             raise EnvironmentError("Could not find CuraEngine")
@@ -99,13 +111,15 @@ class CuraEngineBackend(QObject, Backend):
         application.getPreferences().addPreference("backend/location", self._default_engine_location)
 
         # Workaround to disable layer view processing if layer view is not active.
-        self._layer_view_active = False #type: bool
+        self._layer_view_active: bool = False
         self._onActiveViewChanged()
 
-        self._stored_layer_data = []  # type: List[Arcus.PythonMessage]
-        self._stored_optimized_layer_data = {}  # type: Dict[int, List[Arcus.PythonMessage]] # key is build plate number, then arrays are stored until they go to the ProcessSlicesLayersJob
+        self._stored_layer_data: List[Arcus.PythonMessage] = []
 
-        self._scene = application.getController().getScene() #type: Scene
+        # key is build plate number, then arrays are stored until they go to the ProcessSlicesLayersJob
+        self._stored_optimized_layer_data: Dict[int, List[Arcus.PythonMessage]] = {}
+
+        self._scene: Scene = application.getController().getScene()
         self._scene.sceneChanged.connect(self._onSceneChanged)
 
         # Triggers for auto-slicing. Auto-slicing is triggered as follows:
@@ -116,7 +130,7 @@ class CuraEngineBackend(QObject, Backend):
         # If there is an error check, stop the auto-slicing timer, and only wait for the error check to be finished
         # to start the auto-slicing timer again.
         #
-        self._global_container_stack = None #type: Optional[ContainerStack]
+        self._global_container_stack: Optional[ContainerStack] = None
 
         # Listeners for receiving messages from the back-end.
         self._message_handlers["cura.proto.Layer"] = self._onLayerMessage
@@ -128,31 +142,34 @@ class CuraEngineBackend(QObject, Backend):
         self._message_handlers["cura.proto.PrintTimeMaterialEstimates"] = self._onPrintTimeMaterialEstimates
         self._message_handlers["cura.proto.SlicingFinished"] = self._onSlicingFinishedMessage
 
-        self._start_slice_job = None #type: Optional[StartSliceJob]
-        self._start_slice_job_build_plate = None #type: Optional[int]
-        self._slicing = False #type: bool # Are we currently slicing?
-        self._restart = False #type: bool # Back-end is currently restarting?
-        self._tool_active = False #type: bool # If a tool is active, some tasks do not have to do anything
-        self._always_restart = True #type: bool # Always restart the engine when starting a new slice. Don't keep the process running. TODO: Fix engine statelessness.
-        self._process_layers_job = None #type: Optional[ProcessSlicedLayersJob] # The currently active job to process layers, or None if it is not processing layers.
-        self._build_plates_to_be_sliced = [] #type: List[int] # what needs slicing?
-        self._engine_is_fresh = True #type: bool # Is the newly started engine used before or not?
+        self._start_slice_job: Optional[StartSliceJob] = None
+        self._start_slice_job_build_plate: Optional[int] = None
+        self._slicing: bool = False  # Are we currently slicing?
+        self._restart: bool = False  # Back-end is currently restarting?
+        self._tool_active: bool = False  # If a tool is active, some tasks do not have to do anything
+        self._always_restart: bool = True # Always restart the engine when starting a new slice. Don't keep the process running. TODO: Fix engine statelessness.
+        self._process_layers_job: Optional[ProcessSlicedLayersJob] = None # The currently active job to process layers, or None if it is not processing layers.
+        self._build_plates_to_be_sliced: List[int] = []  # what needs slicing?
+        self._engine_is_fresh: bool = True  # Is the newly started engine used before or not?
 
-        self._backend_log_max_lines = 20000 #type: int # Maximum number of lines to buffer
-        self._error_message = None #type: Optional[Message] # Pop-up message that shows errors.
-        self._last_num_objects = defaultdict(int) #type: Dict[int, int] # Count number of objects to see if there is something changed
-        self._postponed_scene_change_sources = [] #type: List[SceneNode] # scene change is postponed (by a tool)
+        self._backend_log_max_lines: int = 20000  # Maximum number of lines to buffer
+        self._error_message: Optional[Message] = None  # Pop-up message that shows errors.
 
-        self._slice_start_time = None #type: Optional[float]
-        self._is_disabled = False #type: bool
+        # Count number of objects to see if there is something changed
+        self._last_num_objects: Dict[int, int] = defaultdict(int)
+        self._postponed_scene_change_sources: List[SceneNode] = []   # scene change is postponed (by a tool)
+
+        self._time_start_process: Optional[float] = None
+        self._is_disabled: bool = False
 
         application.getPreferences().addPreference("general/auto_slice", False)
 
-        self._use_timer = False #type: bool
-        # When you update a setting and other settings get changed through inheritance, many propertyChanged signals are fired.
-        # This timer will group them up, and only slice for the last setting changed signal.
+        self._use_timer: bool = False
+
+        # When you update a setting and other settings get changed through inheritance, many propertyChanged
+        # signals are fired. This timer will group them up, and only slice for the last setting changed signal.
         # TODO: Properly group propertyChanged signals by whether they are triggered by the same user interaction.
-        self._change_timer = QTimer() #type: QTimer
+        self._change_timer: QTimer = QTimer()
         self._change_timer.setSingleShot(True)
         self._change_timer.setInterval(500)
         self.determineAutoSlicing()
@@ -171,10 +188,48 @@ class CuraEngineBackend(QObject, Backend):
         )
         self._slicing_error_message.actionTriggered.connect(self._reportBackendError)
 
-        self._snapshot = None #type: Optional[QImage]
+        self._resetLastSliceTimeStats()
+        self._snapshot: Optional[QImage] = None 
 
         application.initializationFinished.connect(self.initialize)
 
+    def startPlugins(self) -> None:
+        """
+        Ensure that all backend plugins are started
+        It assigns unique ports to each plugin to avoid conflicts.
+        :return:
+        """
+        self.stopPlugins()
+        backend_plugins = CuraApplication.getInstance().getBackendPlugins()
+        for backend_plugin in backend_plugins:
+            # Set the port to prevent plugins from using the same one.
+            if backend_plugin.getPort() < 1:
+                backend_plugin.setAvailablePort()
+            backend_plugin.start()
+
+    def stopPlugins(self) -> None:
+        """
+        Ensure that all backend plugins will be terminated.
+        """
+        backend_plugins = CuraApplication.getInstance().getBackendPlugins()
+        for backend_plugin in backend_plugins:
+            if backend_plugin.isRunning():
+                backend_plugin.stop()
+
+    def _resetLastSliceTimeStats(self) -> None:
+        self._time_start_process = None
+        self._time_send_message = None
+        self._time_end_slice = None
+
+    def resetAndReturnLastSliceTimeStats(self) -> Dict[str, float]:
+        last_slice_data = {
+            "time_start_process": self._time_start_process,
+            "time_send_message": self._time_send_message,
+            "time_end_slice": self._time_end_slice,
+        }
+        self._resetLastSliceTimeStats()
+        return last_slice_data
+
     def initialize(self) -> None:
         application = CuraApplication.getInstance()
         self._multi_build_plate_model = application.getMultiBuildPlateModel()
@@ -187,7 +242,8 @@ class CuraEngineBackend(QObject, Backend):
         application.getMachineManager().globalContainerChanged.connect(self._onGlobalStackChanged)
         self._onGlobalStackChanged()
 
-        # extruder enable / disable. Actually wanted to use machine manager here, but the initialization order causes it to crash
+        # Extruder enable / disable. Actually wanted to use machine manager here,
+        # but the initialization order causes it to crash
         ExtruderManager.getInstance().extrudersChanged.connect(self._extruderChanged)
 
         self.backendQuit.connect(self._onBackendQuit)
@@ -224,26 +280,14 @@ class CuraEngineBackend(QObject, Backend):
         command += ["connect", "127.0.0.1:{0}".format(self._port), ""]
 
         parser = argparse.ArgumentParser(prog = "cura", add_help = False)
-        parser.add_argument("--debug", action = "store_true", default = False, help = "Turn on the debug mode by setting this option.")
+        parser.add_argument("--debug", action = "store_true", default = False,
+                            help = "Turn on the debug mode by setting this option.")
         known_args = vars(parser.parse_known_args()[0])
         if known_args["debug"]:
             command.append("-vvv")
 
         return command
 
-    printDurationMessage = Signal()
-    """Emitted when we get a message containing print duration and material amount.
-
-    This also implies the slicing has finished.
-    :param time: The amount of time the print will take.
-    :param material_amount: The amount of material the print will use.
-    """
-    slicingStarted = Signal()
-    """Emitted when the slicing process starts."""
-
-    slicingCancelled = Signal()
-    """Emitted when the slicing process is aborted forcefully."""
-
     @pyqtSlot()
     def stopSlicing(self) -> None:
         self.setState(BackendState.NotStarted)
@@ -251,7 +295,8 @@ class CuraEngineBackend(QObject, Backend):
             self._terminate()
             self._createSocket()
 
-        if self._process_layers_job is not None:  # We were processing layers. Stop that, the layers are going to change soon.
+        if self._process_layers_job is not None:
+            # We were processing layers. Stop that, the layers are going to change soon.
             Logger.log("i", "Aborting process layers job...")
             self._process_layers_job.abort()
             self._process_layers_job = None
@@ -266,7 +311,7 @@ class CuraEngineBackend(QObject, Backend):
         self.markSliceAll()
         self.slice()
 
-    @call_on_qt_thread  # must be called from the main thread because of OpenGL
+    @call_on_qt_thread  # Must be called from the main thread because of OpenGL
     def _createSnapshot(self) -> None:
         self._snapshot = None
         if not CuraApplication.getInstance().isVisible:
@@ -275,7 +320,7 @@ class CuraEngineBackend(QObject, Backend):
         Logger.log("i", "Creating thumbnail image (just before slice)...")
         try:
             self._snapshot = Snapshot.snapshot(width = 300, height = 300)
-        except:
+        except Exception:
             Logger.logException("w", "Failed to create snapshot image")
             self._snapshot = None  # Failing to create thumbnail should not fail creation of UFP
 
@@ -287,8 +332,10 @@ class CuraEngineBackend(QObject, Backend):
 
         self._createSnapshot()
 
+        self.startPlugins()
+
         Logger.log("i", "Starting to slice...")
-        self._slice_start_time = time()
+        self._time_start_process = time()
         if not self._build_plates_to_be_sliced:
             self.processingProgress.emit(1.0)
             Logger.log("w", "Slice unnecessary, nothing has changed that needs reslicing.")
@@ -300,7 +347,8 @@ class CuraEngineBackend(QObject, Backend):
             return
 
         if not hasattr(self._scene, "gcode_dict"):
-            self._scene.gcode_dict = {} #type: ignore #Because we are creating the missing attribute here.
+            self._scene.gcode_dict = {}  # type: ignore
+            # We need to ignore type because we are creating the missing attribute here.
 
         # see if we really have to slice
         application = CuraApplication.getInstance()
@@ -311,9 +359,9 @@ class CuraEngineBackend(QObject, Backend):
 
         self._stored_layer_data = []
 
-
         if build_plate_to_be_sliced not in num_objects or num_objects[build_plate_to_be_sliced] == 0:
-            self._scene.gcode_dict[build_plate_to_be_sliced] = [] #type: ignore #Because we created this attribute above.
+            self._scene.gcode_dict[build_plate_to_be_sliced] = []   # type: ignore
+            # We need to ignore the type because we created this attribute above.
             Logger.log("d", "Build plate %s has no objects to be sliced, skipping", build_plate_to_be_sliced)
             if self._build_plates_to_be_sliced:
                 self.slice()
@@ -322,7 +370,7 @@ class CuraEngineBackend(QObject, Backend):
         if application.getPrintInformation() and build_plate_to_be_sliced == active_build_plate:
             application.getPrintInformation().setToZeroPrintInformation(build_plate_to_be_sliced)
 
-        if self._process is None: # type: ignore
+        if self._process is None:  # type: ignore
             self._createSocket()
         self.stopSlicing()
         self._engine_is_fresh = False  # Yes we're going to use the engine
@@ -330,7 +378,7 @@ class CuraEngineBackend(QObject, Backend):
         self.processingProgress.emit(0.0)
         self.backendStateChange.emit(BackendState.NotStarted)
 
-        self._scene.gcode_dict[build_plate_to_be_sliced] = [] #type: ignore #[] indexed by build plate number
+        self._scene.gcode_dict[build_plate_to_be_sliced] = []  # type: ignore #[] indexed by build plate number
         self._slicing = True
         self.slicingStarted.emit()
 
@@ -355,6 +403,8 @@ class CuraEngineBackend(QObject, Backend):
         if self._start_slice_job is not None:
             self._start_slice_job.cancel()
 
+        self.stopPlugins()
+
         self.slicingCancelled.emit()
         self.processingProgress.emit(0)
         Logger.log("d", "Attempting to kill the engine process")
@@ -362,14 +412,15 @@ class CuraEngineBackend(QObject, Backend):
         if CuraApplication.getInstance().getUseExternalBackend():
             return
 
-        if self._process is not None: # type: ignore
+        if self._process is not None:  # type: ignore
             Logger.log("d", "Killing engine process")
             try:
-                self._process.terminate() # type: ignore
-                Logger.log("d", "Engine process is killed. Received return code %s", self._process.wait()) # type: ignore
-                self._process = None # type: ignore
+                self._process.terminate()  # type: ignore
+                Logger.log("d", "Engine process is killed. Received return code %s", self._process.wait())  # type: ignore
+                self._process = None  # type: ignore
 
-            except Exception as e:  # terminating a process that is already terminating causes an exception, silently ignore this.
+            except Exception as e:
+                # Terminating a process that is already terminating causes an exception, silently ignore this.
                 Logger.log("d", "Exception occurred while trying to kill the engine %s", str(e))
 
     def _onStartSliceCompleted(self, job: StartSliceJob) -> None:
@@ -414,14 +465,14 @@ class CuraEngineBackend(QObject, Backend):
                     Logger.log("w", "Global container stack not assigned to CuraEngineBackend!")
                     return
                 extruders = ExtruderManager.getInstance().getActiveExtruderStacks()
-                error_keys = [] #type: List[str]
+                error_keys: List[str] = []
                 for extruder in extruders:
                     error_keys.extend(extruder.getErrorKeys())
                 if not extruders:
                     error_keys = self._global_container_stack.getErrorKeys()
                 error_labels = set()
                 for key in error_keys:
-                    for stack in [self._global_container_stack] + extruders: #Search all container stacks for the definition of this setting. Some are only in an extruder stack.
+                    for stack in [self._global_container_stack] + extruders:  #Search all container stacks for the definition of this setting. Some are only in an extruder stack.
                         definitions = cast(DefinitionContainerInterface, stack.getBottom()).findDefinitions(key = key)
                         if definitions:
                             break #Found it! No need to continue search.
@@ -509,11 +560,13 @@ class CuraEngineBackend(QObject, Backend):
         # Preparation completed, send it to the backend.
         self._socket.sendMessage(job.getSliceMessage())
 
-        # Notify the user that it's now up to the backend to do it's job
+        # Notify the user that it's now up to the backend to do its job
         self.setState(BackendState.Processing)
 
-        if self._slice_start_time:
-            Logger.log("d", "Sending slice message took %s seconds", time() - self._slice_start_time )
+        # Handle time reporting.
+        self._time_send_message = time()
+        if self._time_start_process:
+            Logger.log("d", "Sending slice message took %s seconds", self._time_send_message - self._time_start_process)
 
     def determineAutoSlicing(self) -> bool:
         """Determine enable or disable auto slicing. Return True for enable timer and False otherwise.
@@ -534,7 +587,8 @@ class CuraEngineBackend(QObject, Backend):
                 self._is_disabled = True
             gcode_list = node.callDecoration("getGCodeList")
             if gcode_list is not None:
-                self._scene.gcode_dict[node.callDecoration("getBuildPlateNumber")] = gcode_list #type: ignore #Because we generate this attribute dynamically.
+                self._scene.gcode_dict[node.callDecoration("getBuildPlateNumber")] = gcode_list  # type: ignore
+                # We need to ignore type because we generate this attribute dynamically.
 
         if self._use_timer == enable_timer:
             return self._use_timer
@@ -549,7 +603,7 @@ class CuraEngineBackend(QObject, Backend):
     def _numObjectsPerBuildPlate(self) -> Dict[int, int]:
         """Return a dict with number of objects per build plate"""
 
-        num_objects = defaultdict(int) #type: Dict[int, int]
+        num_objects: Dict[int, int] = defaultdict(int)
         for node in DepthFirstIterator(self._scene.getRoot()):
             # Only count sliceable objects
             if node.callDecoration("isSliceable"):
@@ -629,11 +683,13 @@ class CuraEngineBackend(QObject, Backend):
         self._terminate()
         self._createSocket()
 
-        if error.getErrorCode() not in [Arcus.ErrorCode.BindFailedError, Arcus.ErrorCode.ConnectionResetError, Arcus.ErrorCode.Debug]:
+        if error.getErrorCode() not in [Arcus.ErrorCode.BindFailedError,
+                                        Arcus.ErrorCode.ConnectionResetError,
+                                        Arcus.ErrorCode.Debug]:
             Logger.log("w", "A socket error caused the connection to be reset")
 
         # _terminate()' function sets the job status to 'cancel', after reconnecting to another Port the job status
-        # needs to be updated. Otherwise backendState is "Unable To Slice"
+        # needs to be updated. Otherwise, backendState is "Unable To Slice"
         if error.getErrorCode() == Arcus.ErrorCode.BindFailedError and self._start_slice_job is not None:
             self._start_slice_job.setIsCancelled(False)
 
@@ -655,7 +711,7 @@ class CuraEngineBackend(QObject, Backend):
         for node in DepthFirstIterator(self._scene.getRoot()):
             if node.callDecoration("getLayerData"):
                 if not build_plate_numbers or node.callDecoration("getBuildPlateNumber") in build_plate_numbers:
-                    # We can assume that all nodes have a parent as we're looping through the scene (and filter out root)
+                    # We can assume that all nodes have a parent as we're looping through the scene and filter out root
                     cast(SceneNode, node.getParent()).removeChild(node)
 
     def markSliceAll(self) -> None:
@@ -684,7 +740,7 @@ class CuraEngineBackend(QObject, Backend):
         :param instance: The setting instance that has changed.
         :param property: The property of the setting instance that has changed.
         """
-        if property == "value":  # Only reslice if the value has changed.
+        if property == "value":  # Only re-slice if the value has changed.
             self.needsSlicing()
             self._onChanged()
 
@@ -748,12 +804,17 @@ class CuraEngineBackend(QObject, Backend):
         :param message: The protobuf message signalling that slicing is finished.
         """
 
+        self.stopPlugins()
+
         self.setState(BackendState.Done)
         self.processingProgress.emit(1.0)
+        self._time_end_slice = time()
 
         try:
-            gcode_list = self._scene.gcode_dict[self._start_slice_job_build_plate] #type: ignore #Because we generate this attribute dynamically.
-        except KeyError:  # Can occur if the g-code has been cleared while a slice message is still arriving from the other end.
+            gcode_list = self._scene.gcode_dict[self._start_slice_job_build_plate] #type: ignore
+            # We need to ignore the type because it was generated dynamically.
+        except KeyError:
+            # Can occur if the g-code has been cleared while a slice message is still arriving from the other end.
             gcode_list = []
         application = CuraApplication.getInstance()
         for index, line in enumerate(gcode_list):
@@ -766,8 +827,8 @@ class CuraEngineBackend(QObject, Backend):
             gcode_list[index] = replaced
 
         self._slicing = False
-        if self._slice_start_time:
-            Logger.log("d", "Slicing took %s seconds", time() - self._slice_start_time )
+        if self._time_start_process:
+            Logger.log("d", "Slicing took %s seconds", time() - self._time_start_process)
         Logger.log("d", "Number of models per buildplate: %s", dict(self._numObjectsPerBuildPlate()))
 
         # See if we need to process the sliced layers job.
@@ -798,7 +859,8 @@ class CuraEngineBackend(QObject, Backend):
 
         try:
             self._scene.gcode_dict[self._start_slice_job_build_plate].append(message.data.decode("utf-8", "replace")) #type: ignore #Because we generate this attribute dynamically.
-        except KeyError:  # Can occur if the g-code has been cleared while a slice message is still arriving from the other end.
+        except KeyError:
+            # Can occur if the g-code has been cleared while a slice message is still arriving from the other end.
             pass  # Throw the message away.
 
     def _onGCodePrefixMessage(self, message: Arcus.PythonMessage) -> None:
@@ -810,7 +872,8 @@ class CuraEngineBackend(QObject, Backend):
 
         try:
             self._scene.gcode_dict[self._start_slice_job_build_plate].insert(0, message.data.decode("utf-8", "replace")) #type: ignore #Because we generate this attribute dynamically.
-        except KeyError:  # Can occur if the g-code has been cleared while a slice message is still arriving from the other end.
+        except KeyError:
+            # Can occur if the g-code has been cleared while a slice message is still arriving from the other end.
             pass  # Throw the message away.
 
     def _onSliceUUIDMessage(self, message: Arcus.PythonMessage) -> None:
@@ -937,7 +1000,8 @@ class CuraEngineBackend(QObject, Backend):
         view = CuraApplication.getInstance().getController().getActiveView()
         if view:
             active_build_plate = CuraApplication.getInstance().getMultiBuildPlateModel().activeBuildPlate
-            if view.getPluginId() == "SimulationView":  # If switching to layer view, we should process the layers if that hasn't been done yet.
+            if view.getPluginId() == "SimulationView":
+                # If switching to layer view, we should process the layers if that hasn't been done yet.
                 self._layer_view_active = True
                 # There is data and we're not slicing at the moment
                 # if we are slicing, there is no need to re-calculate the data as it will be invalid in a moment.
@@ -956,7 +1020,6 @@ class CuraEngineBackend(QObject, Backend):
 
         We should reset our state and start listening for new connections.
         """
-
         if not self._restart:
             if self._process: # type: ignore
                 return_code = self._process.wait()
@@ -967,6 +1030,7 @@ class CuraEngineBackend(QObject, Backend):
                     self.stopSlicing()
                 else:
                     Logger.log("d", "Backend finished slicing. Resetting process and socket.")
+                    self.stopPlugins()
                 self._process = None # type: ignore
 
     def _reportBackendError(self, _message_id: str, _action_id: str) -> None:
@@ -989,7 +1053,8 @@ class CuraEngineBackend(QObject, Backend):
         self._global_container_stack = CuraApplication.getInstance().getMachineManager().activeMachine
 
         if self._global_container_stack:
-            self._global_container_stack.propertyChanged.connect(self._onSettingChanged)  # Note: Only starts slicing when the value changed.
+            # Note: Only starts slicing when the value changed.
+            self._global_container_stack.propertyChanged.connect(self._onSettingChanged)
             self._global_container_stack.containersChanged.connect(self._onChanged)
 
             for extruder in self._global_container_stack.extruderList:

plugins/CuraEngineBackend/StartSliceJob.py

@@ -1,5 +1,6 @@
 #  Copyright (c) 2021-2022 Ultimaker B.V.
 #  Cura is released under the terms of the LGPLv3 or higher.
+import os
 
 import numpy
 from string import Formatter
@@ -301,6 +302,23 @@ class StartSliceJob(Job):
         for extruder_stack in global_stack.extruderList:
             self._buildExtruderMessage(extruder_stack)
 
+        for plugin in CuraApplication.getInstance().getBackendPlugins():
+            if not plugin.usePlugin():
+                continue
+            for slot in plugin.getSupportedSlots():
+                # Right now we just send the message for every slot that we support. A single plugin can support
+                # multiple slots
+                # In the future the frontend will need to decide what slots that a plugin actually supports should
+                # also be used. For instance, if you have two plugins and each of them support a_generate and b_generate
+                # only one of each can actually be used (eg; plugin 1 does both, plugin 1 does a_generate and 2 does
+                # b_generate, etc).
+                plugin_message = self._slice_message.addRepeatedMessage("engine_plugins")
+                plugin_message.id = slot
+                plugin_message.address = plugin.getAddress()
+                plugin_message.port = plugin.getPort()
+                plugin_message.plugin_name = plugin.getPluginId()
+                plugin_message.plugin_version = plugin.getVersion()
+
         for group in filtered_object_groups:
             group_message = self._slice_message.addRepeatedMessage("object_lists")
             parent = group[0].getParent()

plugins/DigitalLibrary/src/DFFileExportAndUploadManager.py

@@ -135,9 +135,21 @@ class DFFileExportAndUploadManager:
             file_name = file_upload_response.job_name if file_upload_response.job_name is not None else ""
         else:
             Logger.log("e", "Wrong response type received. Aborting uploading file to the Digital Library")
+            getBackwardsCompatibleMessage(
+                    text = "Upload error",
+                    title = f"Failed to upload {file_name}. Received unexpected response from server.",
+                    message_type_str = "ERROR",
+                    lifetime = 0
+            ).show()
             return
         if file_name not in self._file_upload_job_metadata:
             Logger.error(f"API response for uploading doesn't match the file name we just uploaded: {file_name} was never uploaded.")
+            getBackwardsCompatibleMessage(
+                    text = "Upload error",
+                    title = f"Failed to upload {file_name}. Name doesn't match the one sent back in confirmation.",
+                    message_type_str = "ERROR",
+                    lifetime = 0
+            ).show()
             return
         with self._message_lock:
             self.progress_message.show()

plugins/DigitalLibrary/src/DigitalFactoryController.py

@@ -501,6 +501,12 @@ class DigitalFactoryController(QObject):
         """
         if not download_url:
             Logger.log("e", "No download url for file '{}'".format(file_name))
+            getBackwardsCompatibleMessage(
+                    text = "Download error",
+                    title = f"No download url could be found for '{file_name}'.",
+                    message_type_str = "ERROR",
+                    lifetime = 0
+            ).show()
             return
 
         progress_message = Message(text = "{0}/{1}".format(project_name, file_name), dismissable = False, lifetime = 0,
@@ -584,6 +590,12 @@ class DigitalFactoryController(QObject):
         """
         if self._selected_project_idx == -1:
             Logger.log("e", "No DF Library project is selected.")
+            getBackwardsCompatibleMessage(
+                    text = "No Digital Library project was selected",
+                    title = "No project selected",
+                    message_type_str = "ERROR",
+                    lifetime = 0
+            ).show()
             return
 
         if filename == "":

plugins/GCodeReader/FlavorParser.py

@@ -32,6 +32,7 @@ class FlavorParser:
     """This parser is intended to interpret the common firmware codes among all the different flavors"""
 
     MAX_EXTRUDER_COUNT = 16
+    DEFAULT_FILAMENT_DIAMETER = 2.85
 
     def __init__(self) -> None:
         CuraApplication.getInstance().hideMessageSignal.connect(self._onHideMessage)
@@ -48,7 +49,7 @@ class FlavorParser:
         self._is_layers_in_file = False  # Does the Gcode have the layers comment?
         self._extruder_offsets = {}  # type: Dict[int, List[float]] # Offsets for multi extruders. key is index, value is [x-offset, y-offset]
         self._current_layer_thickness = 0.2  # default
-        self._filament_diameter = 2.85       # default
+        self._current_filament_diameter = 2.85       # default
         self._previous_extrusion_value = 0.0  # keep track of the filament retractions
 
         CuraApplication.getInstance().getPreferences().addPreference("gcodereader/show_caution", True)
@@ -152,7 +153,7 @@ class FlavorParser:
 
     def _calculateLineWidth(self, current_point: Position, previous_point: Position, current_extrusion: float, previous_extrusion: float, layer_thickness: float) -> float:
         # Area of the filament
-        Af = (self._filament_diameter / 2) ** 2 * numpy.pi
+        Af = (self._current_filament_diameter / 2) ** 2 * numpy.pi
         # Length of the extruded filament
         de = current_extrusion - previous_extrusion
         # Volume of the extruded filament
@@ -287,7 +288,11 @@ class FlavorParser:
 
     def processTCode(self, global_stack, T: int, line: str, position: Position, path: List[List[Union[float, int]]]) -> Position:
         self._extruder_number = T
-        self._filament_diameter = global_stack.extruderList[self._extruder_number].getProperty("material_diameter", "value")
+        try:
+            self._current_filament_diameter = global_stack.extruderList[self._extruder_number].getProperty("material_diameter", "value")
+        except IndexError:
+            self._current_filament_diameter = self.DEFAULT_FILAMENT_DIAMETER
+
         if self._extruder_number + 1 > len(position.e):
             self._extrusion_length_offset.extend([0] * (self._extruder_number - len(position.e) + 1))
             position.e.extend([0] * (self._extruder_number - len(position.e) + 1))
@@ -323,7 +328,11 @@ class FlavorParser:
         if not global_stack:
             return None
 
-        self._filament_diameter = global_stack.extruderList[self._extruder_number].getProperty("material_diameter", "value")
+        try:
+            self._current_filament_diameter = global_stack.extruderList[self._extruder_number].getProperty("material_diameter", "value")
+        except IndexError:
+            # There can be a mismatch between the number of extruders in the G-Code file and the number of extruders in the current machine.
+            self._current_filament_diameter = self.DEFAULT_FILAMENT_DIAMETER
 
         scene_node = CuraSceneNode()
 

plugins/MachineSettingsAction/MachineSettingsPrinterTab.qml

@@ -303,18 +303,17 @@ Item
 
                     Component.onCompleted:
                     {
-                        update()
+                        updateModel();
                     }
 
-                    function update()
+                    function updateModel()
                     {
-                        clear()
-                        for (var i = 1; i <= Cura.MachineManager.activeMachine.maxExtruderCount; i++)
-                        {
+                        clear();
+                        for (var i = 1; i <= Cura.MachineManager.activeMachine.maxExtruderCount; i ++) {
                             // Use String as value. JavaScript only has Number. PropertyProvider.setPropertyValue()
                             // takes a QVariant as value, and Number gets translated into a float. This will cause problem
                             // for integer settings such as "Number of Extruders".
-                            append({ text: String(i), value: String(i) })
+                            append({ text: String(i), value: String(i) });
                         }
                     }
                 }
@@ -322,7 +321,9 @@ Item
                 Connections
                 {
                     target: Cura.MachineManager
-                    function onGlobalContainerChanged() { extruderCountModel.update() }
+                    function onGlobalContainerChanged() {
+                        extruderCountModel.updateModel();
+                    }
                 }
             }
 

plugins/Marketplace/MissingPackageList.py

@@ -20,7 +20,6 @@ class MissingPackageList(RemotePackageList):
     def __init__(self, packages_metadata: List[Dict[str, str]], parent: Optional["QObject"] = None) -> None:
         super().__init__(parent)
         self._packages_metadata: List[Dict[str, str]] = packages_metadata
-        self._package_type_filter = "material"
         self._search_type = "package_ids"
         self._requested_search_string = ",".join(map(lambda package: package["id"], packages_metadata))
 
@@ -38,7 +37,14 @@ class MissingPackageList(RemotePackageList):
 
         for package_metadata in self._packages_metadata:
             if package_metadata["id"] not in returned_packages_ids:
-                package = PackageModel.fromIncompletePackageInformation(package_metadata["display_name"], package_metadata["package_version"], self._package_type_filter)
+                package_type = package_metadata["type"] if "type" in package_metadata else "material"
+                # When this feature was originally introduced only missing materials were detected. With the inclusion
+                # of backend plugins this system was extended to also detect missing plugins. With that change the type
+                # of the package was added to the metadata. Project files before this change do not have this type. So
+                # if the type is not present we assume it is a material.
+                package = PackageModel.fromIncompletePackageInformation(package_metadata["display_name"],
+                                                                        package_metadata["package_version"],
+                                                                        package_type)
                 self.appendItem({"package": package})
 
         self.itemsChanged.emit()

plugins/Marketplace/PackageModel.py

@@ -87,12 +87,22 @@ class PackageModel(QObject):
         self._is_missing_package_information = False
 
     @classmethod
-    def fromIncompletePackageInformation(cls, display_name: str, package_version: str, package_type: str) -> "PackageModel":
+    def fromIncompletePackageInformation(cls, display_name: str, package_version: str,
+                                         package_type: str) -> "PackageModel":
+        description = ""
+        match package_type:
+            case "material":
+                description = catalog.i18nc("@label:label Ultimaker Marketplace is a brand name, don't translate",
+                                            "The material package associated with the Cura project could not be found on the Ultimaker Marketplace. Use the partial material profile definition stored in the Cura project file at your own risk.")
+            case "plugin":
+                description = catalog.i18nc("@label:label Ultimaker Marketplace is a brand name, don't translate",
+                                            "The plugin associated with the Cura project could not be found on the Ultimaker Marketplace. As the plugin may be required to slice the project it might not be possible to correctly slice the file.")
+
         package_data = {
             "display_name": display_name,
             "package_version": package_version,
             "package_type": package_type,
-            "description": catalog.i18nc("@label:label Ultimaker Marketplace is a brand name, don't translate", "The material package associated with the Cura project could not be found on the Ultimaker Marketplace. Use the partial material profile definition stored in the Cura project file at your own risk.")
+            "description": description,
         }
         package_model = cls(package_data)
         package_model.setIsMissingPackageInformation(True)

plugins/Marketplace/RemotePackageList.py

@@ -21,6 +21,7 @@ catalog = i18nCatalog("cura")
 
 class RemotePackageList(PackageList):
     ITEMS_PER_PAGE = 20  # Pagination of number of elements to download at once.
+    SORT_TYPE = "last_updated"   # Default value to send for sort_by filter.
 
     def __init__(self, parent: Optional["QObject"] = None) -> None:
         super().__init__(parent)
@@ -28,6 +29,7 @@ class RemotePackageList(PackageList):
         self._package_type_filter = ""
         self._requested_search_string = ""
         self._current_search_string = ""
+        self._search_sort = "sort_by"
         self._search_type = "search"
         self._request_url = self._initialRequestUrl()
         self._ongoing_requests["get_packages"] = None
@@ -102,6 +104,8 @@ class RemotePackageList(PackageList):
             request_url += f"&package_type={self._package_type_filter}"
         if self._current_search_string != "":
             request_url += f"&{self._search_type}={self._current_search_string}"
+        if self.SORT_TYPE:
+            request_url += f"&{self._search_sort}={self.SORT_TYPE}"
         return request_url
 
     def _parseResponse(self, reply: "QNetworkReply") -> None:

plugins/Marketplace/plugin.json

@@ -3,6 +3,6 @@
     "author": "Ultimaker B.V.",
     "version": "1.0.0",
     "api": 8,
-    "description": "Manages extensions to the application and allows browsing extensions from the Ultimaker website.",
+    "description": "Manages extensions to the application and allows browsing extensions from the UltiMaker website.",
     "i18n-catalog": "cura"
 }

plugins/Marketplace/resources/qml/InstallMissingPackagesDialog.qml

@@ -12,7 +12,7 @@ import Cura 1.6 as Cura
 Marketplace
 {
     modality: Qt.ApplicationModal
-    title: catalog.i18nc("@title", "Install missing Materials")
+    title: catalog.i18nc("@title", "Install missing packages")
     pageContentsSource: "MissingPackages.qml"
     showSearchHeader: false
     showOnboadBanner: false

plugins/Marketplace/resources/qml/Marketplace.qml

@@ -280,9 +280,38 @@ Window
                 onClicked:
                 {
                     marketplaceDialog.hide();
-                    CuraApplication.closeApplication();
+                    CuraApplication.checkAndExitApplication();
                 }
             }
         }
     }
+
+    Rectangle
+    {
+        color: UM.Theme.getColor("main_background")
+        anchors.fill: parent
+        visible: !Cura.API.account.isLoggedIn && CuraApplication.isEnterprise
+
+        UM.Label
+        {
+            id: signInLabel
+            anchors.centerIn: parent
+            width: Math.round(UM.Theme.getSize("modal_window_minimum").width / 2.5)
+            text: catalog.i18nc("@description","Please sign in to get verified plugins and materials for UltiMaker Cura Enterprise")
+            horizontalAlignment: Text.AlignHCenter
+        }
+
+        Cura.PrimaryButton
+        {
+            id: loginButton
+            width: UM.Theme.getSize("account_button").width
+            height: UM.Theme.getSize("account_button").height
+            anchors.horizontalCenter: parent.horizontalCenter
+            anchors.top: signInLabel.bottom
+            anchors.topMargin: UM.Theme.getSize("default_margin").height * 2
+            text: catalog.i18nc("@button", "Sign in")
+            fixedWidthMode: true
+            onClicked: Cura.API.account.login()
+        }
+    }
 }

plugins/Marketplace/resources/qml/MissingPackages.qml

@@ -5,7 +5,7 @@ import UM 1.4 as UM
 
 Packages
 {
-    pageTitle: catalog.i18nc("@header", "Install Materials")
+    pageTitle: catalog.i18nc("@header", "Install Packages")
 
     bannerVisible: false
     showUpdateButton: false

plugins/PerObjectSettingsTool/PerObjectSettingsPanel.qml

@@ -1,7 +1,7 @@
 //Copyright (c) 2022 Ultimaker B.V.
 //Cura is released under the terms of the LGPLv3 or higher.
 
-import QtQuick 2.2
+import QtQuick 2.15
 import QtQuick.Controls 2.15
 
 import UM 1.5 as UM
@@ -167,11 +167,7 @@ Item
 
             onActivated:
             {
-                if (index == 0){
-                    setMeshType(infillMeshType)
-                } else {
-                    setMeshType(cuttingMeshType)
-                }
+                setMeshType(index === 0 ? infillMeshType : cuttingMeshType);
             }
 
             Binding
@@ -204,21 +200,21 @@ Item
                 model: UM.SettingDefinitionsModel
                 {
                     id: addedSettingsModel
-                    containerId: Cura.MachineManager.activeMachine != null ? Cura.MachineManager.activeMachine.definition.id: ""
-                    expanded: [ "*" ]
+                    containerId: Cura.MachineManager.activeMachine !== null ? Cura.MachineManager.activeMachine.definition.id: ""
+                    expanded: ["*"]
                     filter:
                     {
-                        if (printSequencePropertyProvider.properties.value == "one_at_a_time")
+                        if (printSequencePropertyProvider.properties.value === "one_at_a_time")
                         {
-                            return {"settable_per_meshgroup": true}
+                            return { settable_per_meshgroup: true }
                         }
-                        return {"settable_per_mesh": true}
+                        return { settable_per_meshgroup: true }
                     }
                     exclude:
                     {
-                        var excluded_settings = [ "support_mesh", "anti_overhang_mesh", "cutting_mesh", "infill_mesh" ]
+                        const excluded_settings = ["support_mesh", "anti_overhang_mesh", "cutting_mesh", "infill_mesh"]
 
-                        if (currentMeshType == "support_mesh")
+                        if (currentMeshType === "support_mesh")
                         {
                             excluded_settings = excluded_settings.concat(base.allCategoriesExceptSupport)
                         }
@@ -238,15 +234,15 @@ Item
                         setDestroyed(true)
                     }
                 }
-
+                property int indexWithFocus: -1
                 delegate: Row
                 {
                     spacing: UM.Theme.getSize("default_margin").width
+                    property var settingLoaderItem: settingLoader.item
                     Loader
                     {
                         id: settingLoader
                         width: UM.Theme.getSize("setting").width - removeButton.width - scrollBar.width
-                        height: UM.Theme.getSize("section").height + UM.Theme.getSize("narrow_margin").height
                         enabled: provider.properties.enabled === "True"
                         property var definition: model
                         property var settingDefinitionsModel: addedSettingsModel
@@ -257,7 +253,7 @@ Item
                         //Qt5.4.2 and earlier has a bug where this causes a crash: https://bugreports.qt.io/browse/QTBUG-35989
                         //In addition, while it works for 5.5 and higher, the ordering of the actual combo box drop down changes,
                         //causing nasty issues when selecting different options. So disable asynchronous loading of enum type completely.
-                        asynchronous: model.type != "enum" && model.type != "extruder"
+                        asynchronous: model.type !== "enum" && model.type !== "extruder"
 
                         onLoaded:
                         {
@@ -266,6 +262,7 @@ Item
                             settingLoader.item.showLinkedSettingIcon = false
                             settingLoader.item.doDepthIndentation = false
                             settingLoader.item.doQualityUserSettingEmphasis = false
+                            settingLoader.item.height = UM.Theme.getSize("setting").height + UM.Theme.getSize("narrow_margin").height
                         }
 
                         sourceComponent:
@@ -344,6 +341,44 @@ Item
                         function onPropertiesChanged() { provider.forcePropertiesChanged() }
                     }
 
+                    Connections
+                    {
+                        target: settingLoader.item
+                        function onFocusReceived()
+                        {
+
+                            contents.indexWithFocus = index
+                            contents.positionViewAtIndex(index, ListView.Contain)
+                        }
+                        function onSetActiveFocusToNextSetting(forward)
+                        {
+                            if (forward == undefined || forward)
+                            {
+                                contents.currentIndex = contents.indexWithFocus + 1
+                                while(contents.currentItem && contents.currentItem.height <= 0)
+                                {
+                                    contents.currentIndex++
+                                }
+                                if (contents.currentItem)
+                                {
+                                    contents.currentItem.settingLoaderItem.focusItem.forceActiveFocus()
+                                }
+                            }
+                            else
+                            {
+                                contents.currentIndex = contents.indexWithFocus - 1
+                                while(contents.currentItem && contents.currentItem.height <= 0)
+                                {
+                                    contents.currentIndex--
+                                }
+                                if (contents.currentItem)
+                                {
+                                    contents.currentItem.settingLoaderItem.focusItem.forceActiveFocus()
+                                }
+                            }
+                        }
+                    }
+
                     Connections
                     {
                         target: UM.ActiveTool
@@ -362,11 +397,11 @@ Item
                             if (typeof UM.ActiveTool.properties.getValue("ContainerID") !== "undefined")
                             {
                                 const containerId = UM.ActiveTool.properties.getValue("ContainerID")
-                                if (provider.containerStackId != containerId)
+                                if (provider.containerStackId !== containerId)
                                 {
                                     provider.containerStackId = containerId
                                 }
-                                if (inheritStackProvider.containerStackId != containerId)
+                                if (inheritStackProvider.containerStackId !== containerId)
                                 {
                                     inheritStackProvider.containerStackId = containerId
                                 }
@@ -388,13 +423,13 @@ Item
             onClicked:
             {
                 settingPickDialog.visible = true;
-                if (currentMeshType == "support_mesh")
+                if (currentMeshType === "support_mesh")
                 {
                     settingPickDialog.additional_excluded_settings = base.allCategoriesExceptSupport;
                 }
                 else
                 {
-                    settingPickDialog.additional_excluded_settings = []
+                    settingPickDialog.additional_excluded_settings = [];
                 }
             }
         }
@@ -412,7 +447,7 @@ Item
 
         containerStack: Cura.MachineManager.activeMachine
         key: "machine_extruder_count"
-        watchedProperties: [ "value" ]
+        watchedProperties: ["value"]
         storeIndex: 0
     }
 
@@ -422,56 +457,15 @@ Item
 
         containerStack: Cura.MachineManager.activeMachine
         key: "print_sequence"
-        watchedProperties: [ "value" ]
+        watchedProperties: ["value"]
         storeIndex: 0
     }
 
-    Component
-    {
-        id: settingTextField
-
-        Cura.SettingTextField { }
-    }
-
-    Component
-    {
-        id: settingComboBox
-
-        Cura.SettingComboBox { }
-    }
-
-    Component
-    {
-        id: settingExtruder
-
-        Cura.SettingExtruder { }
-    }
-
-    Component
-    {
-        id: settingOptionalExtruder
-
-        Cura.SettingOptionalExtruder { }
-    }
-
-    Component
-    {
-        id: settingCheckBox
-
-        Cura.SettingCheckBox { }
-    }
-
-    Component
-    {
-        id: settingCategory
-
-        Cura.SettingCategory { }
-    }
-
-    Component
-    {
-        id: settingUnknown
-
-        Cura.SettingUnknown { }
-    }
+    Component { id: settingTextField; Cura.SettingTextField { } }
+    Component { id: settingComboBox; Cura.SettingComboBox { } }
+    Component { id: settingExtruder; Cura.SettingExtruder { } }
+    Component { id: settingOptionalExtruder; Cura.SettingOptionalExtruder { } }
+    Component { id: settingCheckBox; Cura.SettingCheckBox { } }
+    Component { id: settingCategory; Cura.SettingCategory { } }
+    Component { id: settingUnknown; Cura.SettingUnknown { } }
 }

plugins/PostProcessingPlugin/PostProcessingPlugin.py

@@ -1,5 +1,5 @@
 # Copyright (c) 2018 Jaime van Kessel, Ultimaker B.V.
-# The PostProcessingPlugin is released under the terms of the AGPLv3 or higher.
+# The PostProcessingPlugin is released under the terms of the LGPLv3 or higher.
 
 import configparser  # The script lists are stored in metadata as serialised config files.
 import importlib.util
@@ -139,22 +139,28 @@ class PostProcessingPlugin(QObject, Extension):
         if self._loaded_scripts: # Already loaded.
             return
 
-        # The PostProcessingPlugin path is for built-in scripts.
-        # The Resources path is where the user should store custom scripts.
-        # The Preferences path is legacy, where the user may previously have stored scripts.
-        resource_folders = [PluginRegistry.getInstance().getPluginPath("PostProcessingPlugin"), Resources.getStoragePath(Resources.Preferences)]
-        resource_folders.extend(Resources.getAllPathsForType(Resources.Resources))
-        for root in resource_folders:
-            if root is None:
-                continue
-            path = os.path.join(root, "scripts")
+        # Make sure a "scripts" folder exists in the main configuration folder and the preferences folder.
+        # On some platforms the resources and preferences folders resolve to the same folder,
+        # but on Linux they can be different.
+        for path in set([os.path.join(Resources.getStoragePath(r), "scripts") for r in [Resources.Resources, Resources.Preferences]]):
             if not os.path.isdir(path):
                 try:
                     os.makedirs(path)
                 except OSError:
                     Logger.log("w", "Unable to create a folder for scripts: " + path)
-                    continue
 
+        # The PostProcessingPlugin path is for built-in scripts.
+        # The Resources path is where the user should store custom scripts.
+        # The Preferences path is legacy, where the user may previously have stored scripts.
+        resource_folders = [PluginRegistry.getInstance().getPluginPath("PostProcessingPlugin"), Resources.getStoragePath(Resources.Preferences)]
+        resource_folders.extend(Resources.getAllPathsForType(Resources.Resources))
+
+        for root in resource_folders:
+            if root is None:
+                continue
+            path = os.path.join(root, "scripts")
+            if not os.path.isdir(path):
+                continue
             self.loadScripts(path)
 
     def loadScripts(self, path: str) -> None:

plugins/PostProcessingPlugin/PostProcessingPlugin.qml

@@ -1,5 +1,5 @@
 // Copyright (c) 2022 Jaime van Kessel, Ultimaker B.V.
-// The PostProcessingPlugin is released under the terms of the AGPLv3 or higher.
+// The PostProcessingPlugin is released under the terms of the LGPLv3 or higher.
 
 import QtQuick 2.2
 import QtQuick.Controls 2.15

plugins/PostProcessingPlugin/Script.py

@@ -1,6 +1,6 @@
 # Copyright (c) 2015 Jaime van Kessel
 # Copyright (c) 2018 Ultimaker B.V.
-# The PostProcessingPlugin is released under the terms of the AGPLv3 or higher.
+# The PostProcessingPlugin is released under the terms of the LGPLv3 or higher.
 from typing import Optional, Any, Dict, TYPE_CHECKING, List
 
 from UM.Signal import Signal, signalemitter

plugins/PostProcessingPlugin/scripts/ChangeAtZ.py

@@ -1,7 +1,7 @@
 # ChangeAtZ script - Change printing parameters at a given height
 # This script is the successor of the TweakAtZ plugin for legacy Cura.
 # It contains code from the TweakAtZ plugin V1.0-V4.x and from the ExampleScript by Jaime van Kessel, Ultimaker B.V.
-# It runs with the PostProcessingPlugin which is released under the terms of the AGPLv3 or higher.
+# It runs with the PostProcessingPlugin which is released under the terms of the LGPLv3 or higher.
 # This script is licensed under the Creative Commons - Attribution - Share Alike (CC BY-SA) terms
 
 # Authors of the ChangeAtZ plugin / script:

plugins/PostProcessingPlugin/scripts/ColorMix.py

@@ -1,6 +1,6 @@
 # ColorMix script - 2-1 extruder color mix and blending
 # This script is specific for the Geeetech A10M dual extruder but should work with other Marlin printers. 
-# It runs with the PostProcessingPlugin which is released under the terms of the AGPLv3 or higher.
+# It runs with the PostProcessingPlugin which is released under the terms of the LGPLv3 or higher.
 # This script is licensed under the Creative Commons - Attribution - Share Alike (CC BY-SA) terms
 
 #Authors of the 2-1 ColorMix plug-in / script:

plugins/PostProcessingPlugin/scripts/FilamentChange.py

@@ -1,5 +1,5 @@
-# Copyright (c) 2021 Ultimaker B.V.
-# The PostProcessingPlugin is released under the terms of the AGPLv3 or higher.
+# Copyright (c) 2023 Ultimaker B.V.
+# The PostProcessingPlugin is released under the terms of the LGPLv3 or higher.
 
 # Modification 06.09.2020
 # add checkbox, now you can choose and use configuration from the firmware itself.
@@ -199,7 +199,7 @@ class FilamentChange(Script):
         if enable_before_macro:
             color_change = color_change + before_macro + "\n"
 
-        color_change = color_change + "M600\n"
+        color_change = color_change + "M600"
 
         if not firmware_config:
             if initial_retract is not None and initial_retract > 0.:
@@ -213,13 +213,15 @@ class FilamentChange(Script):
 
             if x_pos is not None:
                 color_change = color_change + (" X%.2f" % x_pos)
-                
+
             if y_pos is not None:
                 color_change = color_change + (" Y%.2f" % y_pos)
-                
+
             if z_pos is not None and z_pos > 0.:
                 color_change = color_change + (" Z%.2f" % z_pos)
 
+        color_change = color_change + "\n"
+
         if enable_after_macro:
             color_change = color_change + after_macro + "\n"
 

plugins/PostProcessingPlugin/scripts/LimitXYAccelJerk.py

@@ -0,0 +1,326 @@
+# Limit XY Accel:  Authored by: Greg Foresi (GregValiant)
+# July 2023
+# Sometimes bed-slinger printers need different Accel and Jerk values for the Y but Cura always makes them the same.
+# This script changes the Accel and/or Jerk from the beginning of the 'Start Layer' to the end of the 'End Layer'.
+# The existing M201 Max Accel will be changed to limit the Y (and/or X) accel at the printer.  If you have Accel enabled in Cura and the XY Accel is set to 3000 then setting the Y limit to 1000 will result in the printer limiting the Y to 1000.  This can keep tall skinny prints from breaking loose of the bed and failing.  The script was not tested with Junction Deviation.
+# If enabled - the Jerk setting is changed line-by-line within the gcode as there is no "limit" on Jerk.
+# if 'Gradual ACCEL change' is enabled then the Accel is changed gradually from the Start to the End layer and that will be the final Accel setting in the file.  If 'Gradual' is enabled then the Jerk settings will continue to be changed to the end of the file (rather than ending at the End layer).
+# This post is intended for printers with moving beds (bed slingers) so UltiMaker printers are excluded.
+# When setting an accel limit on multi-extruder printers ALL extruders are effected.
+# This post does not distinguish between Print Accel and Travel Accel.  The limit is the limit for all regardless.  Example: Skin Accel = 1000 and Outer Wall accel = 500.  If the limit is set to 300 then both Skin and Outer Wall will be Accel = 300.
+
+from ..Script import Script
+from cura.CuraApplication import CuraApplication
+import re
+from UM.Message import Message
+
+class LimitXYAccelJerk(Script):
+        
+    def initialize(self) -> None:
+        super().initialize()
+        # Get the Accel and Jerk and set the values in the setting boxes--
+        mycura = CuraApplication.getInstance().getGlobalContainerStack()
+        extruder = mycura.extruderList
+        accel_print = extruder[0].getProperty("acceleration_print", "value")
+        accel_travel = extruder[0].getProperty("acceleration_travel", "value")
+        jerk_print_old = extruder[0].getProperty("jerk_print", "value")
+        jerk_travel_old = extruder[0].getProperty("jerk_travel", "value")
+        self._instance.setProperty("x_accel_limit", "value", round(accel_print))
+        self._instance.setProperty("y_accel_limit", "value", round(accel_print))
+        self._instance.setProperty("x_jerk", "value", jerk_print_old)
+        self._instance.setProperty("y_jerk", "value", jerk_print_old)
+        ext_count = int(mycura.getProperty("machine_extruder_count", "value"))
+        machine_name = str(mycura.getProperty("machine_name", "value"))
+                
+        # Warn the user if the printer is an Ultimaker-------------------------
+        if "Ultimaker" in machine_name:
+            Message(text = "<NOTICE> [Limit the X-Y Accel/Jerk] DID NOT RUN because Ultimaker printers don't have sliding beds.").show()
+        
+        # Warn the user if the printer is multi-extruder------------------
+        if ext_count > 1:
+            Message(text = "<NOTICE> 'Limit the X-Y Accel/Jerk': The post processor treats all extruders the same.  If you have multiple extruders they will all be subject to the same Accel and Jerk limits imposed.  If you have different Travel and Print Accel they will also be subject to the same limits.  If that is not acceptable then you should not use this Post Processor.").show()
+ 
+    def getSettingDataString(self):
+            return """{
+            "name": "Limit the X-Y Accel/Jerk (all extruders equal)",
+            "key": "LimitXYAccelJerk",
+            "metadata": {},
+            "version": 2,
+            "settings":
+            {
+                "type_of_change":
+                {
+                    "label": "Immediate or Gradual change",
+                    "description": "An 'Immediate' change will insert the new numbers immediately at the Start Layer.  A 'Gradual' change will transition from the starting Accel to the new Accel limit across a range of layers.",
+                    "type": "enum",
+                    "options": {
+                        "immediate_change": "Immediate",
+                        "gradual_change": "Gradual"},
+                    "default_value": "immediate_change"
+                },
+                "x_accel_limit":
+                {
+                    "label": "X MAX Acceleration",
+                    "description": "If this number is lower than the 'X Print Accel' in Cura then this will limit the Accel on the X axis.  Enter the Maximum Acceleration value for the X axis.  This will affect both Print and Travel Accel.  If you enable an End Layer then at the end of that layer the Accel Limit will be reset (unless you choose 'Gradual' in which case the new limit goes to the top layer).",
+                    "type": "int",
+                    "enabled": true,
+                    "minimum_value": 50,
+                    "unit": "mm/sec² ",
+                    "default_value": 500
+                },
+                "y_accel_limit":
+                {
+                    "label": "Y MAX Acceleration",
+                    "description": "If this number is lower than the Y accel in Cura then this will limit the Accel on the Y axis.  Enter the Maximum Acceleration value for the Y axis.  This will affect both Print and Travel Accel.  If you enable an End Layer then at the end of that layer the Accel Limit will be reset (unless you choose 'Gradual' in which case the new limit goes to the top layer).",
+                    "type": "int",
+                    "enabled": true,
+                    "minimum_value": 50,
+                    "unit": "mm/sec² ",
+                    "default_value": 500
+                },
+                "jerk_enable":
+                {
+                    "label": "Change the Jerk",
+                    "description": "Whether to change the Jerk values.",
+                    "type": "bool",
+                    "enabled": true,
+                    "default_value": false
+                },
+                "x_jerk":
+                {
+                    "label": "    X jerk",
+                    "description": "Enter the Jerk value for the X axis.  Enter '0' to use the existing X Jerk.  This setting will affect both the Print and Travel jerk.",
+                    "type": "int",
+                    "enabled": "jerk_enable",
+                    "unit": "mm/sec ",
+                    "default_value": 8
+                },
+                "y_jerk":
+                {
+                    "label": "    Y jerk",
+                    "description": "Enter the Jerk value for the Y axis. Enter '0' to use the existing Y Jerk.    This setting will affect both the Print and Travel jerk.",
+                    "type": "int",
+                    "enabled": "jerk_enable",
+                    "unit": "mm/sec ",
+                    "default_value": 8
+                },
+                "start_layer":
+                {
+                    "label": "From Start of Layer:",
+                    "description": "Use the Cura Preview numbers. Enter the Layer to start the changes at. The minimum is Layer 1.",
+                    "type": "int",
+                    "default_value": 1,
+                    "minimum_value": 1,
+                    "unit": "Lay# ",
+                    "enabled": "type_of_change == 'immediate_change'"
+                },
+                "end_layer":
+                {
+                    "label": "To End of Layer",
+                    "description": "Use the Cura Preview numbers. Enter '-1' for the entire file or enter a layer number.  The changes will end at your 'End Layer' and revert back to the original numbers.",
+                    "type": "int",
+                    "default_value": -1,
+                    "minimum_value": -1,
+                    "unit": "Lay# ",
+                    "enabled": "type_of_change == 'immediate_change'"
+                },
+                "gradient_start_layer":
+                {
+                    "label": "     Gradual From Layer:",
+                    "description": "Use the Cura Preview numbers. Enter the Layer to start the changes at. The minimum is Layer 1.",
+                    "type": "int",
+                    "default_value": 1,
+                    "minimum_value": 1,
+                    "unit": "Lay# ",
+                    "enabled": "type_of_change == 'gradual_change'"
+                },
+                "gradient_end_layer":
+                {
+                    "label": "     Gradual To Layer",
+                    "description": "Use the Cura Preview numbers. Enter '-1' for the top layer or enter a layer number.  The last 'Gradual' change will continue to the end of the file.",
+                    "type": "int",
+                    "default_value": -1,
+                    "minimum_value": -1,
+                    "unit": "Lay# ",
+                    "enabled": "type_of_change == 'gradual_change'"
+                }
+            }
+        }"""
+
+    def execute(self, data):
+        mycura = CuraApplication.getInstance().getGlobalContainerStack()
+        extruder = mycura.extruderList
+        machine_name = str(mycura.getProperty("machine_name", "value"))
+        print_sequence = str(mycura.getProperty("print_sequence", "value"))
+        
+        # Exit if 'one_at_a_time' is enabled-------------------------
+        if print_sequence == "one_at_a_time":
+            Message(text = "<NOTICE> [Limit the X-Y Accel/Jerk]  DID NOT RUN.  This post processor is not compatible with 'One-at-a-Time' mode.").show()
+            data[0] += ";  [LimitXYAccelJerk] DID NOT RUN because Cura is set to 'One-at-a-Time' mode.\n"
+            return data
+                
+        # Exit if the printer is an Ultimaker-------------------------
+        if "Ultimaker" in machine_name:
+            Message(text = "<NOTICE> [Limit the X-Y Accel/Jerk]  DID NOT RUN.  This post processor is for bed slinger printers only.").show()
+            data[0] += ";  [LimitXYAccelJerk] DID NOT RUN because the printer doesn't have a sliding bed.\n"
+            return data
+            
+        type_of_change = str(self.getSettingValueByKey("type_of_change"))
+        accel_print_enabled = bool(extruder[0].getProperty("acceleration_enabled", "value"))
+        accel_travel_enabled = bool(extruder[0].getProperty("acceleration_travel_enabled", "value"))
+        accel_print = extruder[0].getProperty("acceleration_print", "value")
+        accel_travel = extruder[0].getProperty("acceleration_travel", "value")
+        jerk_print_enabled = str(extruder[0].getProperty("jerk_enabled", "value"))
+        jerk_travel_enabled = str(extruder[0].getProperty("jerk_travel_enabled", "value"))
+        jerk_print_old = extruder[0].getProperty("jerk_print", "value")
+        jerk_travel_old = extruder[0].getProperty("jerk_travel", "value")
+        
+        if int(accel_print) >= int(accel_travel):
+            accel_old = accel_print
+        else:
+            accel_old = accel_travel
+        jerk_travel = str(extruder[0].getProperty("jerk_travel", "value"))
+        if int(jerk_print_old) >= int(jerk_travel_old):
+            jerk_old = jerk_print_old
+        else:
+            jerk_old = jerk_travel_old
+
+        #Set the new Accel values----------------------------------------------------------
+        x_accel = str(self.getSettingValueByKey("x_accel_limit"))
+        y_accel = str(self.getSettingValueByKey("y_accel_limit"))
+        x_jerk = int(self.getSettingValueByKey("x_jerk"))  
+        y_jerk = int(self.getSettingValueByKey("y_jerk"))
+        
+        # Put the strings together-------------------------------------------
+        m201_limit_new = "M201 X" + x_accel + " Y" + y_accel
+        m201_limit_old = "M201 X" + str(round(accel_old)) + " Y" + str(round(accel_old))
+        if x_jerk == 0:
+            m205_jerk_pattern = "Y(\d*)"
+            m205_jerk_new = "Y" + str(y_jerk)
+        if y_jerk == 0:
+            m205_jerk_pattern = "X(\d*)"
+            m205_jerk_new = "X" + str(x_jerk)
+        if x_jerk != 0 and y_jerk != 0:
+            m205_jerk_pattern = "M205 X(\d*) Y(\d*)"
+            m205_jerk_new = "M205 X" + str(x_jerk) + " Y" + str(y_jerk)
+        m205_jerk_old = "M205 X" + str(jerk_old) + " Y" + str(jerk_old)
+        type_of_change = self.getSettingValueByKey("type_of_change") 
+        
+        #Get the indexes of the start and end layers----------------------------------------
+        if type_of_change == 'immediate_change':
+            start_layer = int(self.getSettingValueByKey("start_layer"))-1
+            end_layer = int(self.getSettingValueByKey("end_layer"))
+        else:
+            start_layer = int(self.getSettingValueByKey("gradient_start_layer"))-1
+            end_layer = int(self.getSettingValueByKey("gradient_end_layer"))
+        start_index = 2
+        end_index = len(data)-2
+        for num in range(2,len(data)-1):
+            if ";LAYER:" + str(start_layer) + "\n" in data[num]:
+                start_index = num
+                break
+        if int(end_layer) > 0:
+            for num in range(3,len(data)-1):
+                try:
+                    if ";LAYER:" + str(end_layer) + "\n" in data[num]:
+                        end_index = num
+                        break
+                except:
+                    end_index = len(data)-2      
+
+        #Add Accel limit and new Jerk at start layer-----------------------------------------------------
+        if type_of_change == "immediate_change":
+            layer = data[start_index]
+            lines = layer.split("\n")
+            for index, line in enumerate(lines):
+                if lines[index].startswith(";LAYER:"):
+                    lines.insert(index+1,m201_limit_new)
+                    if self.getSettingValueByKey("jerk_enable"):
+                        lines.insert(index+2,m205_jerk_new)
+                    data[start_index] = "\n".join(lines)
+                    break
+            
+            #Alter any existing jerk lines.  Accel lines can be ignored-----------------------------------  
+            for num in range(start_index,end_index,1):
+                layer = data[num]
+                lines = layer.split("\n")
+                for index, line in enumerate(lines):
+                    if line.startswith("M205"):
+                        lines[index] = re.sub(m205_jerk_pattern, m205_jerk_new, line)
+                data[num] = "\n".join(lines)
+            if end_layer != -1:
+                try:
+                    layer = data[end_index-1]
+                    lines = layer.split("\n")
+                    lines.insert(len(lines)-2,m201_limit_old)
+                    lines.insert(len(lines)-2,m205_jerk_old)
+                    data[end_index-1] = "\n".join(lines)
+                except:
+                    pass
+            else:
+                data[len(data)-1] = m201_limit_old + "\n" + m205_jerk_old + "\n" + data[len(data)-1]
+            return data        
+        
+        elif type_of_change == "gradual_change":
+            layer_spread = end_index - start_index
+            if accel_old >= int(x_accel):
+                x_accel_hyst = round((accel_old - int(x_accel)) / layer_spread)
+            else:
+                x_accel_hyst = round((int(x_accel) - accel_old) / layer_spread)
+            if accel_old >= int(y_accel):
+                y_accel_hyst = round((accel_old - int(y_accel)) / layer_spread)
+            else:                
+                y_accel_hyst = round((int(y_accel) - accel_old) / layer_spread)
+            
+            if accel_old >= int(x_accel):
+                x_accel_start = round(round((accel_old - x_accel_hyst)/25)*25)
+            else:
+                x_accel_start = round(round((x_accel_hyst + accel_old)/25)*25)
+            if accel_old >= int(y_accel):
+                y_accel_start = round(round((accel_old - y_accel_hyst)/25)*25)
+            else:
+                y_accel_start = round(round((y_accel_hyst + accel_old)/25)*25)
+            m201_limit_new = "M201 X" + str(x_accel_start) + " Y" + str(y_accel_start)
+            #Add Accel limit and new Jerk at start layer-------------------------------------------------------------
+            layer = data[start_index]
+            lines = layer.split("\n")
+            for index, line in enumerate(lines):
+                if lines[index].startswith(";LAYER:"):
+                    lines.insert(index+1,m201_limit_new)
+                    if self.getSettingValueByKey("jerk_enable"):
+                        lines.insert(index+2,m205_jerk_new)
+                    data[start_index] = "\n".join(lines)
+                    break
+            for num in range(start_index + 1, end_index,1):
+                layer = data[num]
+                lines = layer.split("\n")
+                if accel_old >= int(x_accel):
+                    x_accel_start -= x_accel_hyst
+                    if x_accel_start < int(x_accel): x_accel_start = int(x_accel)
+                else:
+                    x_accel_start += x_accel_hyst                
+                    if x_accel_start > int(x_accel): x_accel_start = int(x_accel)
+                if accel_old >= int(y_accel):
+                    y_accel_start -= y_accel_hyst
+                    if y_accel_start < int(y_accel): y_accel_start = int(y_accel)
+                else:
+                    y_accel_start += y_accel_hyst
+                    if y_accel_start > int(y_accel): y_accel_start = int(y_accel)
+                m201_limit_new = "M201 X" + str(round(round(x_accel_start/25)*25)) + " Y" + str(round(round(y_accel_start/25)*25))
+                for index, line in enumerate(lines):
+                    if line.startswith(";LAYER:"):
+                        lines.insert(index+1, m201_limit_new)
+                        continue
+                data[num] = "\n".join(lines)
+            
+            #Alter any existing jerk lines.  Accel lines can be ignored---------------
+            if self.getSettingValueByKey("jerk_enable"):
+                for num in range(start_index,len(data)-1,1):
+                    layer = data[num]
+                    lines = layer.split("\n")
+                    for index, line in enumerate(lines):
+                        if line.startswith("M205"):
+                            lines[index] = re.sub(m205_jerk_pattern, m205_jerk_new, line)
+                    data[num] = "\n".join(lines)
+                data[len(data)-1] = m201_limit_old + "\n" + m205_jerk_old + "\n" + data[len(data)-1]
+            return data

plugins/PostProcessingPlugin/scripts/PauseAtHeight.py

@@ -46,7 +46,7 @@ class PauseAtHeight(Script):
                 "pause_layer":
                 {
                     "label": "Pause Layer",
-                    "description": "Enter the Number of the LAST layer you want to finish prior to the pause (from the Cura preview).",
+                    "description": "Enter the Number of the LAST layer you want to finish prior to the pause. Note that 0 is the first layer printed.",
                     "type": "int",
                     "value": "math.floor((pause_height - 0.27) / 0.1) + 1",
                     "minimum_value": "0",
@@ -67,7 +67,7 @@ class PauseAtHeight(Script):
                     "label": "Keep motors engaged",
                     "description": "Keep the steppers engaged to allow change of filament without moving the head. Applying too much force will move the head/bed anyway",
                     "type": "bool",
-                    "default_value": true,
+                    "default_value": false,
                     "enabled": "pause_method != \\\"griffin\\\""
                 },
                 "disarm_timeout":
@@ -218,7 +218,7 @@ class PauseAtHeight(Script):
                     "label": "Beep at pause",
                     "description": "Make a beep when pausing",
                     "type": "bool",
-                    "default_value": true
+                    "default_value": false
                 },                
                 "beep_length":
                 {
@@ -338,7 +338,7 @@ class PauseAtHeight(Script):
                     nbr_negative_layers += 1
 
                 #Track the latest printing temperature in order to resume at the correct temperature.
-                if line.startswith("T"):
+                if re.match("T(\d*)", line):
                     current_t = self.getValue(line, "T")
                 m = self.getValue(line, "M")
                 if m is not None and (m == 104 or m == 109) and self.getValue(line, "S") is not None:
@@ -478,10 +478,11 @@ class PauseAtHeight(Script):
                     prepend_gcode += "M117 " + display_text + "\n"
 
                 # Set the disarm timeout
-                if hold_steppers_on:
-                    prepend_gcode += self.putValue(M = 84, S = 3600) + " ; Keep steppers engaged for 1h\n"
-                elif disarm_timeout > 0:
-                    prepend_gcode += self.putValue(M = 84, S = disarm_timeout) + " ; Set the disarm timeout\n"
+                if pause_method != "griffin":
+                    if hold_steppers_on:
+                        prepend_gcode += self.putValue(M = 84, S = 3600) + " ; Keep steppers engaged for 1h\n"
+                    elif disarm_timeout > 0:
+                        prepend_gcode += self.putValue(M = 84, S = disarm_timeout) + " ; Set the disarm timeout\n"
 
                 # Beep at pause
                 if beep_at_pause: