Merge branch 'Ultimaker:main' into master

.dockerignore

@@ -1,4 +0,0 @@
-.git
-.github
-resources/materials
-CuraEngine

.github/ISSUE_TEMPLATE/bugreport.yaml

@@ -1,6 +1,6 @@
 name: Bug Report
 description: Create a report to help us fix issues.
-labels: "Type: Bug"
+labels: ["Type: Bug", "Status: Triage"]
 body:
 - type: markdown
   attributes:
@@ -14,7 +14,7 @@ body:
   attributes:
     label: Application Version
     description: The version of Cura this issue occurs with.
-    placeholder: 4.9.0
+    placeholder: 5.0.0
   validations:
     required: true
 - type: input

.github/ISSUE_TEMPLATE/featurerequest.yaml

@@ -1,6 +1,6 @@
 name: Feature Request
 description: Suggest an idea for this project.
-labels: "Type: New Feature"
+labels: ["Type: New Feature", "Status: Triage"]
 body:
 - type: markdown
   attributes:
@@ -41,4 +41,4 @@ body:
 - type: textarea
   attributes:
     label: Additional information & file uploads
-    description: You can add pictures or files to visualize your feature request in the comments below.
+    description: You can add pictures or files to visualize your feature request in the comments below.

.github/no-response.yml

@@ -1,13 +0,0 @@
-# Configuration for probot-no-response - https://github.com/probot/no-response
-
-# Number of days of inactivity before an Issue is closed for lack of response
-daysUntilClose: 14
-# Label requiring a response
-responseRequiredLabel: 'Status: Needs Info'
-# Comment to post when closing an Issue for lack of response. Set to `false` to disable
-closeComment: >
-  This issue has been automatically closed because there has been no response
-  to our request for more information from the original author. With only the
-  information that is currently in the issue, we don't have enough information
-  to take action. Please reach out if you have or find the answers we need so
-  that we can investigate further.

.github/workflows/ci.yml

@@ -1,21 +0,0 @@
----
-name: CI
-on:
-  push:
-    branches:
-      - master
-      - 'WIP**'
-      - '4.*'
-      - 'CURA-*'
-  pull_request:
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    container: ultimaker/cura-build-environment
-    steps:
-    - name: Checkout Cura
-      uses: actions/checkout@v2
-    - name: Build
-      run: docker/build.sh
-    - name: Test
-      run: docker/test.sh

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

@@ -0,0 +1,187 @@
+name: Create and Upload Conan package
+
+on:
+    workflow_call:
+        inputs:
+            project_name:
+                required: true
+                type: string
+
+            recipe_id_full:
+                required: true
+                type: string
+
+            build_id:
+                required: true
+                type: number
+
+            build_info:
+                required: false
+                default: true
+                type: boolean
+
+            recipe_id_latest:
+                required: false
+                type: string
+
+            runs_on:
+                required: true
+                type: string
+
+            python_version:
+                required: true
+                type: string
+
+            conan_config_branch:
+                required: false
+                type: string
+
+            conan_logging_level:
+                required: false
+                type: string
+
+            conan_clean_local_cache:
+                required: false
+                type: boolean
+                default: false
+
+            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
+
+jobs:
+    conan-package-create:
+        runs-on: ${{ inputs.runs_on }}
+
+        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: Install Python requirements for runner
+                run: pip install -r .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: 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 (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 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
+
+            -   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: 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: 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: 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 using lockfile
+                if: ${{ inputs.build_info }}
+                run: conan install ${{ inputs.recipe_id_full }} --build=missing --update --lockfile=conan.lock --lockfile-out=conan.lock
+
+            -   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

.github/workflows/conan-package.yml

@@ -0,0 +1,116 @@
+---
+name: conan-package
+
+# Exports the recipe, sources and binaries for Mac, Windows and Linux and upload these to the server such that these can
+# be used downstream.
+#
+# 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'
+
+    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: {}
+jobs:
+    conan-recipe-version:
+        permissions:
+          contents: read
+
+        uses: ultimaker/cura/.github/workflows/conan-recipe-version.yml@main
+        with:
+            project_name: cura
+
+    conan-package-export:
+        permissions:
+          contents: read
+
+        needs: [ conan-recipe-version ]
+        uses: ultimaker/cura/.github/workflows/conan-recipe-export.yml@main
+        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
+
+    conan-package-create-linux:
+        permissions:
+          contents: read
+
+        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 ]
+
+        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
+
+    notify-export:
+        if: ${{ always() }}
+        needs: [ conan-recipe-version, conan-package-export ]
+
+        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
+
+    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 ]
+
+        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

@@ -0,0 +1,106 @@
+name: Export Conan Recipe to server
+
+on:
+    workflow_call:
+        inputs:
+            recipe_id_full:
+                required: true
+                type: string
+
+            recipe_id_latest:
+                required: false
+                type: string
+
+            runs_on:
+                required: true
+                type: string
+
+            python_version:
+                required: true
+                type: string
+
+            conan_config_branch:
+                required: false
+                type: string
+
+            conan_logging_level:
+                required: false
+                type: string
+
+            conan_export_binaries:
+                required: false
+                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
+
+jobs:
+    package-export:
+        runs-on: ${{ inputs.runs_on }}
+
+        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: Install Python requirements and Create default Conan profile
+                run: |
+                    pip install -r .github/workflows/requirements-conan-package.txt
+                    conan profile new default --detect
+
+            -   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
+                if: ${{ inputs.conan_config_branch == '' }}
+                run: conan config install https://github.com/Ultimaker/conan-config.git
+
+            -   name: Export the Package (binaries)
+                if: ${{ inputs.conan_export_binaries }}
+                run: conan create . ${{ inputs.recipe_id_full }} --build=missing --update
+
+            -   name: Export the Package
+                if: ${{ !inputs.conan_export_binaries }}
+                run: conan export . ${{ inputs.recipe_id_full }}
+
+            -   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: Create the latest alias
+                if: ${{ inputs.recipe_id_latest != '' && 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) community
+                if: ${{ always() && inputs.conan_upload_community == true }}
+                run: conan upload "*" -r cura-ce -c

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

@@ -0,0 +1,201 @@
+name: Get Conan Recipe Version
+
+on:
+    workflow_call:
+        inputs:
+            project_name:
+                required: true
+                type: string
+
+            additional_buildmetadata:
+                required: false
+                default: ""
+                type: string
+
+        outputs:
+            recipe_id_full:
+                description: "The full Conan recipe id: <name>/<version>@<user>/<channel>"
+                value: ${{ jobs.get-semver.outputs.recipe_id_full }}
+
+            recipe_id_latest:
+                description: "The full Conan recipe aliased (latest) id: <name>/(latest)@<user>/<channel>"
+                value: ${{ jobs.get-semver.outputs.recipe_id_latest }}
+
+            recipe_semver_full:
+                description: "The full semver <Major>.<Minor>.<Patch>-<PreReleaseTag>+<BuildMetaData>"
+                value: ${{ jobs.get-semver.outputs.semver_full }}
+
+            is_release_branch:
+                description: "is current branch a release branch?"
+                value: ${{ jobs.get-semver.outputs.release_branch }}
+
+            user:
+                description: "The conan user"
+                value: ${{ jobs.get-semver.outputs.user }}
+
+            channel:
+                description: "The conan channel"
+                value: ${{ jobs.get-semver.outputs.channel }}
+
+            project_name:
+                description: "The conan projectname"
+                value: ${{ inputs.project_name }}
+
+jobs:
+    get-semver:
+
+        runs-on: ubuntu-latest
+
+        outputs:
+            recipe_id_full: ${{ steps.get-conan-broadcast-data.outputs.recipe_id_full }}
+            recipe_id_latest: ${{ steps.get-conan-broadcast-data.outputs.recipe_id_latest }}
+            semver_full: ${{ steps.get-conan-broadcast-data.outputs.semver_full }}
+            is_release_branch: ${{ steps.get-conan-broadcast-data.outputs.is_release_branch }}
+            user: ${{ steps.get-conan-broadcast-data.outputs.user }}
+            channel: ${{ steps.get-conan-broadcast-data.outputs.channel }}
+
+        steps:
+            -   name: Checkout repo
+                uses: actions/checkout@v3
+                if: ${{ github.event.pull_request.head.repo.full_name == github.repository }}
+                with:
+                    fetch-depth: 0
+                    ref: ${{ github.head_ref }}
+
+            -   name: Checkout repo PR
+                uses: actions/checkout@v3
+                if: ${{ github.event.pull_request.head.repo.full_name != github.repository }}
+                with:
+                    fetch-depth: 0
+                    ref: ${{ github.base_ref }}
+
+            -   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 and Create default Conan profile
+                run: |
+                    pip install -r .github/workflows/requirements-conan-package.txt
+                    pip install gitpython
+
+            -   id: get-conan-broadcast-data
+                name: Get Conan broadcast data
+                run: |
+                    import subprocess
+                    import os
+                    from conans import tools
+                    from conans.errors import ConanException
+                    from git import Repo
+                    
+                    repo = Repo('.')
+                    user = "${{ github.repository_owner }}".lower()
+                    project_name = "${{ inputs.project_name }}"
+                    event_name = "${{ github.event_name }}"
+                    issue_number = "${{ github.ref }}".split('/')[2]
+                    is_tag = "${{ github.ref_type }}" == "tag"
+                    is_release_branch = False
+                    ref_name = "${{ github.base_ref }}" if event_name == "pull_request" else "${{ github.ref_name }}"
+                    buildmetadata = "" if "${{ inputs.additional_buildmetadata }}" == "" else "${{ inputs.additional_buildmetadata }}_"
+                    
+                    # FIXME: for when we push a tag (such as an release)
+                    channel = "testing"
+                    if is_tag:
+                        branch_version = tools.Version(ref_name)
+                        is_release_branch = True
+                        channel = "_"
+                        user = "_"
+                        actual_version = f"{branch_version}"
+                    else:
+                        try:
+                            branch_version = tools.Version(repo.active_branch.name)
+                        except ConanException:
+                            branch_version = tools.Version('0.0.0')
+                        if ref_name == f"{branch_version.major}.{branch_version.minor}":
+                            channel = 'stable'
+                            is_release_branch = True
+                        elif ref_name in ("main", "master"):
+                            channel = 'testing'
+                        else:
+                            channel = "_".join(repo.active_branch.name.replace("-", "_").split("_")[:2]).lower()
+                    
+                        if "pull_request" in event_name:
+                            channel = f"pr_{issue_number}"
+                    
+                        # %% Get the actual version
+                        latest_branch_version = tools.Version("0.0.0")
+                        latest_branch_tag = None
+                        for tag in repo.git.tag(merged = True).splitlines():
+                            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)
+                            except ConanException:
+                                continue
+                            if version > latest_branch_version:
+                                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:
+                                # The prerealese did not contain a version number, default it to 1
+                                latest_branch_version_prerelease = f"{latest_branch_version.prerelease}.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}"
+                            else:
+                                if channel in ("stable", "_", ""):
+                                    channel_metadata = f"{no_commits}"
+                                else:
+                                    channel_metadata = f"{channel}_{no_commits}"
+                            if is_release_branch:
+                                if latest_branch_version.prerelease == "":
+                                    # An actual full release has been created, we are working on patch
+                                    bump_up_patch = int(latest_branch_version.patch) + 1
+                                    actual_version = f"{latest_branch_version.major}.{latest_branch_version.minor}.{bump_up_patch}-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}"
+                            else:
+                                bump_up_minor = int(latest_branch_version.minor) + 1
+                                reset_patch = 0
+                                actual_version = f"{latest_branch_version.major}.{bump_up_minor}.{reset_patch}-alpha+{buildmetadata}{channel_metadata}"
+
+                    # %% Set the environment output
+                    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"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")
+                    
+                    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::")
+                shell: python

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

@@ -0,0 +1,112 @@
+name: Cura All Installers
+run-name: ${{ inputs.cura_conan_version }} for Windows ${{ inputs.build_windows }}, MacOS ${{ inputs.build_macos }}, Linux ${{ inputs.build_linux }}
+
+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:
+                description: 'Build for Windows'
+                default: true
+                required: true
+                type: boolean
+            build_linux:
+                description: 'Build for Linux'
+                default: true
+                required: true
+                type: boolean
+            build_macos:
+                description: 'Build 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:
+        if: ${{ inputs.build_windows }}
+        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 }}
+        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 }}
+        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 }}
+        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 }}
+        secrets: inherit

.github/workflows/cura-installer.yml

@@ -0,0 +1,268 @@
+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
+
+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_PASS: ${{ secrets.MACOS_CERT_PASS }}
+    MACOS_CERT_USER: ${{ secrets.MACOS_CERT_USER }}
+    GPG_PRIVATE_KEY: ${{ secrets.GPG_PRIVATE_KEY }}
+    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.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 .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: 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
+
+            -   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.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: 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: Configure GPG Key Linux (Bash)
+                if: ${{ runner.os == 'Linux' }}
+                run: echo -n "$GPG_PRIVATE_KEY" | base64 --decode | gpg --import
+
+            -   name: Configure Macos keychain (Bash)
+                id: macos-keychain
+                if: ${{ runner.os == 'Macos' }}
+                uses: apple-actions/import-codesign-certs@v1
+                with:
+                    p12-file-base64: ${{ secrets.MACOS_CERT_P12 }}
+                    p12-password: ${{ secrets.MACOS_CERT_PASSPHRASE }}
+
+            -   name: Clean Conan local cache
+                if: ${{ inputs.conan_clean_local_cache }}
+                run: conan remove "*" -f
+
+            -   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: 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: |
+                    .\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.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: Archive the artifacts (bash)
+                if: ${{ github.event.inputs.installer == 'false' && runner.os != 'Windows' }}
+                run: tar -zcf "./UltiMaker-Cura-$CURA_VERSION_FULL-${{ inputs.os_name }}.tar.gz" "./UltiMaker-Cura/"
+                working-directory: dist
+
+            -   name: Archive the artifacts (Powershell)
+                if: ${{ github.event.inputs.installer == 'false' && runner.os == 'Windows' }}
+                run: Compress-Archive -Path ".\UltiMaker-Cura" -DestinationPath ".\UltiMaker-Cura-$Env:CURA_VERSION_FULL-${{ inputs.os_name }}.zip"
+                working-directory: dist
+
+            -   name: Create the Windows exe installer (Powershell)
+                if: ${{ github.event.inputs.installer == 'true' && runner.os == 'Windows' }}
+                run: |
+                    python ..\cura_inst\packaging\NSIS\create_windows_installer.py ../cura_inst . "UltiMaker-Cura-$Env:CURA_VERSION_FULL-${{ inputs.os_name }}.exe"
+                working-directory: dist
+
+            -   name: Create the Linux AppImage (Bash)
+                if: ${{ github.event.inputs.installer == 'true' && runner.os == 'Linux' }}
+                run: python ../cura_inst/packaging/AppImage/create_appimage.py ./UltiMaker-Cura $CURA_VERSION_FULL "UltiMaker-Cura-$CURA_VERSION_FULL-${{ inputs.os_name }}.AppImage"
+                working-directory: dist
+
+            -   name: Create the MacOS dmg (Bash)
+                if: ${{ github.event.inputs.installer == 'true' && runner.os == 'Macos' }}
+                run: python ../cura_inst/packaging/dmg/dmg_sign_noterize.py ../cura_inst . "UltiMaker-Cura-$CURA_VERSION_FULL-${{ inputs.os_name }}.dmg"
+                working-directory: dist
+
+            -   name: Upload the artifacts
+                uses: actions/upload-artifact@v3
+                with:
+                    name: UltiMaker-Cura-${{ env.CURA_VERSION_FULL }}-${{ inputs.os_name }}
+                    path: |
+                        dist/*.tar.gz
+                        dist/*.zip
+                        dist/*.exe
+                        dist/*.msi
+                        dist/*.dmg
+                        dist/*.AppImage
+                        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/no-response.yml

@@ -0,0 +1,31 @@
+name: No Response
+
+# Both `issue_comment` and `scheduled` event types are required for this Action
+# to work properly.
+on:
+  issue_comment:
+    types: [created]
+  schedule:
+    # Schedule for ten minutes after the hour, every hour
+    - cron: '* */12 * * *'
+
+# By specifying the access of one of the scopes, all of those that are not
+# specified are set to 'none'.
+permissions:
+  issues: write
+
+jobs:
+  noResponse:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: lee-dohm/no-response@v0.5.0
+        with:
+          token: ${{ github.token }}
+          daysUntilClose: 14
+          responseRequiredLabel: 'Status: Needs Info'
+          closeComment: >
+                This issue has been automatically closed because there has been no response
+                to our request for more information from the original author. With only the
+                information that is currently in the issue, we don't have enough information
+                to take action. Please reach out if you have or find the answers we need so
+                that we can investigate further.

.github/workflows/notify.yml

@@ -0,0 +1,54 @@
+name: Get Conan Recipe Version
+
+on:
+    workflow_call:
+        inputs:
+            success:
+                required: true
+                type: boolean
+
+            success_title:
+                required: true
+                type: string
+
+            success_body:
+                required: true
+                type: string
+
+            failure_title:
+                required: true
+                type: string
+
+            failure_body:
+                required: true
+                type: string
+
+
+jobs:
+    slackNotification:
+        name: Slack Notification
+
+        runs-on: ubuntu-latest
+
+        steps:
+            -   name: Slack notify on-success
+                if: ${{ inputs.success }}
+                uses: rtCamp/action-slack-notify@v2
+                env:
+                    SLACK_USERNAME: ${{ github.repository }}
+                    SLACK_COLOR: green
+                    SLACK_ICON: https://github.com/Ultimaker/Cura/blob/main/icons/cura-128.png?raw=true
+                    SLACK_TITLE: ${{ inputs.success_title }}
+                    SLACK_MESSAGE: ${{ inputs.success_body }}
+                    SLACK_WEBHOOK: ${{ secrets.SLACK_WEBHOOK }}
+
+            -   name: Slack notify on-failure
+                if: ${{ !inputs.success }}
+                uses: rtCamp/action-slack-notify@v2
+                env:
+                    SLACK_USERNAME: ${{ github.repository }}
+                    SLACK_COLOR: red
+                    SLACK_ICON: https://github.com/Ultimaker/Cura/blob/main/icons/cura-128.png?raw=true
+                    SLACK_TITLE: ${{ inputs.failure_title }}
+                    SLACK_MESSAGE: ${{ inputs.failure_body }}
+                    SLACK_WEBHOOK: ${{ secrets.SLACK_WEBHOOK }}

.github/workflows/notify_on_print_profile_change.yml

@@ -0,0 +1,36 @@
+name: notify_on_print_profile_change
+
+on:
+  push:
+    branches: [ "main" ]
+    paths:
+        - 'resources/definitions/fdmprinter.def.json'
+        - 'resources/definitions/ultimaker**'
+        - 'resources/extruders/ultimaker**'
+        - 'resources/intent/ultimaker**'
+        - 'resources/quality/ultimaker**'
+        - 'resources/variants/ultimaker**'
+  pull_request:
+    branches: [ "main" ]
+    paths:
+        - 'resources/definitions/fdmprinter.def.json'
+        - 'resources/definitions/ultimaker**'
+        - 'resources/extruders/ultimaker**'
+        - 'resources/intent/ultimaker**'
+        - 'resources/quality/ultimaker**'
+        - 'resources/variants/ultimaker**'
+permissions: {}
+jobs:
+    slackNotification:
+        name: Slack Notification
+        runs-on: ubuntu-latest
+        steps:
+            -   name: Ultimaker Print Profile Changed
+                uses: rtCamp/action-slack-notify@v2
+                env:
+                    SLACK_CHANNEL: profile-changes
+                    SLACK_USERNAME: ${{ github.repository }}
+                    SLACK_COLOR: '#00FF00'
+                    SLACK_TITLE: Print profiles changed
+                    MSG_MINIMAL: commit
+                    SLACK_WEBHOOK: ${{ secrets.SLACK_CURA_PPM_HOOK }}

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

@@ -0,0 +1,45 @@
+name: printer-linter-format
+
+on:
+    push:
+        paths:
+            - 'resources/definitions/**'
+            - 'resources/extruders/**'
+            - 'resources/intent/**'
+            - 'resources/quality/**'
+            - 'resources/variants/**'
+
+jobs:
+    printer-linter-format:
+        name: Printer linter auto format
+
+        runs-on: ubuntu-latest
+        steps:
+            -   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: Install Python requirements for runner
+                if: env.GIT_DIFF && !env.MATCHED_FILES
+                run: pip install -r .github/workflows/requirements-printer-linter.txt
+
+            -   name: Format file
+                if: env.GIT_DIFF && !env.MATCHED_FILES
+                run: python printer-linter/src/terminal.py --format ${{ env.GIT_DIFF_FILTERED }}
+
+            -   uses: stefanzweifel/git-auto-commit-action@v4
+                if: env.GIT_DIFF && !env.MATCHED_FILES
+                with:
+                    commit_message: "Applied printer-linter format"

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

@@ -0,0 +1,59 @@
+name: printer-linter-pr-diagnose
+
+on:
+  pull_request:
+    path:
+      - "resources/**"
+
+jobs:
+  printer-linter-diagnose:
+    name: Printer linter PR diagnose
+
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+        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: Install Python requirements for runner
+        if: env.GIT_DIFF && !env.MATCHED_FILES
+        run: pip install -r .github/workflows/requirements-printer-linter.txt
+
+      - name: Create results directory
+        run: mkdir printer-linter-result
+
+      - name: Diagnose file(s)
+        if: env.GIT_DIFF && !env.MATCHED_FILES
+        run: python printer-linter/src/terminal.py --diagnose --report printer-linter-result/fixes.yml ${{ env.GIT_DIFF_FILTERED }}
+
+      - name: Save PR metadata
+        run: |
+          echo ${{ github.event.number }} > printer-linter-result/pr-id.txt
+          echo ${{ github.event.pull_request.head.repo.full_name }} > printer-linter-result/pr-head-repo.txt
+          echo ${{ github.event.pull_request.head.ref }} > printer-linter-result/pr-head-ref.txt
+
+      - uses: actions/upload-artifact@v2
+        with:
+          name: printer-linter-result
+          path: printer-linter-result/
+
+      - name: Run clang-tidy-pr-comments action
+        uses: platisd/clang-tidy-pr-comments@bc0bb7da034a8317d54e7fe1e819159002f4cc40
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          clang_tidy_fixes: result.yml
+          request_changes: true

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

@@ -0,0 +1,81 @@
+name: printer-linter-pr-post
+
+on:
+  workflow_run:
+    workflows: ["printer-linter-pr-diagnose"]
+    types: [completed]
+
+jobs:
+  clang-tidy-results:
+    # Trigger the job only if the previous (insecure) workflow completed successfully
+    if: ${{ github.event.workflow_run.event == 'pull_request' && github.event.workflow_run.conclusion == 'success' }}
+    runs-on: ubuntu-latest
+    steps:
+      - name: Download analysis results
+        uses: actions/github-script@v3.1.0
+        with:
+          script: |
+            let artifacts = await github.actions.listWorkflowRunArtifacts({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                run_id: ${{github.event.workflow_run.id }},
+            });
+            let matchArtifact = artifacts.data.artifacts.filter((artifact) => {
+                return artifact.name == "printer-linter-result"
+            })[0];
+            let download = await github.actions.downloadArtifact({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                artifact_id: matchArtifact.id,
+                archive_format: "zip",
+            });
+            let fs = require("fs");
+            fs.writeFileSync("${{github.workspace}}/printer-linter-result.zip", Buffer.from(download.data));
+
+      - name: Set environment variables
+        run: |
+          mkdir printer-linter-result
+          unzip printer-linter-result.zip -d printer-linter-result
+          echo "pr_id=$(cat printer-linter-result/pr-id.txt)" >> $GITHUB_ENV
+          echo "pr_head_repo=$(cat printer-linter-result/pr-head-repo.txt)" >> $GITHUB_ENV
+          echo "pr_head_ref=$(cat printer-linter-result/pr-head-ref.txt)" >> $GITHUB_ENV
+
+      - uses: actions/checkout@v3
+        with:
+          repository: ${{ env.pr_head_repo }}
+          ref: ${{ env.pr_head_ref }}
+          persist-credentials: false
+
+      - name: Redownload analysis results
+        uses: actions/github-script@v3.1.0
+        with:
+          script: |
+            let artifacts = await github.actions.listWorkflowRunArtifacts({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                run_id: ${{github.event.workflow_run.id }},
+            });
+            let matchArtifact = artifacts.data.artifacts.filter((artifact) => {
+                return artifact.name == "printer-linter-result"
+            })[0];
+            let download = await github.actions.downloadArtifact({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                artifact_id: matchArtifact.id,
+                archive_format: "zip",
+            });
+            let fs = require("fs");
+            fs.writeFileSync("${{github.workspace}}/printer-linter-result.zip", Buffer.from(download.data));
+
+      - name: Extract analysis results
+        run: |
+          mkdir printer-linter-result
+          unzip printer-linter-result.zip -d printer-linter-result
+
+      - name: Run clang-tidy-pr-comments action
+        uses: platisd/clang-tidy-pr-comments@bc0bb7da034a8317d54e7fe1e819159002f4cc40
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          clang_tidy_fixes: printer-linter-result/fixes.yml
+          pull_request_id: ${{ env.pr_id }}
+          request_changes: true

.github/workflows/process-pull-request.yml

@@ -0,0 +1,15 @@
+name: process-pull-request
+
+on:
+    pull_request_target:
+        types: [opened, reopened, edited, synchronize, review_requested, ready_for_review, assigned]
+
+jobs:
+    add_label:
+        runs-on: ubuntu-latest
+        steps:
+            -   uses: actions/checkout@v2
+            -   uses: actions-ecosystem/action-add-labels@v1
+                if: ${{ github.event.pull_request.head.repo.full_name != github.repository }}
+                with:
+                    labels: 'PR: Community Contribution :crown:'

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

@@ -0,0 +1,2 @@
+conan!=1.51.0,!=1.51.1,!=1.51.2,!=1.51.3,!=1.52.0
+sip

.github/workflows/requirements-printer-linter.txt

@@ -0,0 +1 @@
+pyyaml

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

@@ -0,0 +1,82 @@
+name: unit-test-post
+
+on:
+    workflow_run:
+        workflows: [ "unit-test" ]
+        types: [ completed ]
+
+jobs:
+    publish-test-results:
+        if: ${{ github.event.workflow_run.event == 'pull_request' && github.event.workflow_run.conclusion == 'success' }}
+        runs-on: ubuntu-latest
+
+        steps:
+            -   name: Download analysis results
+                uses: actions/github-script@v3.1.0
+                with:
+                    script: |
+                        let artifacts = await github.actions.listWorkflowRunArtifacts({
+                            owner: context.repo.owner,
+                            repo: context.repo.repo,
+                            run_id: ${{github.event.workflow_run.id }},
+                        });
+                        let matchArtifact = artifacts.data.artifacts.filter((artifact) => {
+                            return artifact.name == "test-result"
+                        })[0];
+                        let download = await github.actions.downloadArtifact({
+                            owner: context.repo.owner,
+                            repo: context.repo.repo,
+                            artifact_id: matchArtifact.id,
+                            archive_format: "zip",
+                        });
+                        let fs = require("fs");
+                        fs.writeFileSync("${{github.workspace}}/test-result.zip", Buffer.from(download.data));
+
+            -   name: Set environment variables
+                run: |
+                    mkdir pr_env
+                    unzip test-result.zip -d pr_env
+                    echo "pr_id=$(cat pr_env/pr-id.txt)" >> $GITHUB_ENV
+                    echo "pr_head_repo=$(cat pr_env/pr-head-repo.txt)" >> $GITHUB_ENV
+                    echo "pr_head_ref=$(cat pr_env/pr-head-ref.txt)" >> $GITHUB_ENV
+
+            -   uses: actions/checkout@v3
+                with:
+                    repository: ${{ env.pr_head_repo }}
+                    ref: ${{ env.pr_head_ref }}
+                    persist-credentials: false
+
+            -   name: Redownload analysis results
+                uses: actions/github-script@v3.1.0
+                with:
+                    script: |
+                        let artifacts = await github.actions.listWorkflowRunArtifacts({
+                            owner: context.repo.owner,
+                            repo: context.repo.repo,
+                            run_id: ${{github.event.workflow_run.id }},
+                        });
+                        let matchArtifact = artifacts.data.artifacts.filter((artifact) => {
+                            return artifact.name == "test-result"
+                        })[0];
+                        let download = await github.actions.downloadArtifact({
+                            owner: context.repo.owner,
+                            repo: context.repo.repo,
+                            artifact_id: matchArtifact.id,
+                            archive_format: "zip",
+                        });
+                        let fs = require("fs");
+                        fs.writeFileSync("${{github.workspace}}/test-result.zip", Buffer.from(download.data));
+
+            -   name: Extract analysis results
+                run: |
+                    mkdir -p tests
+                    unzip test-result.zip -d tests
+
+            -   name: Publish Unit Test Results
+                id: test-results
+                uses: EnricoMi/publish-unit-test-result-action@v1
+                with:
+                    files: "tests/**/*.xml"
+
+            -   name: Conclusion
+                run: echo "Conclusion is ${{ fromJSON( steps.test-results.outputs.json ).conclusion }}"

.github/workflows/unit-test.yml

@@ -0,0 +1,157 @@
+---
+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'
+
+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
+
+permissions:
+  contents: read
+
+jobs:
+    conan-recipe-version:
+        uses: ultimaker/cura/.github/workflows/conan-recipe-version.yml@main
+        with:
+            project_name: cura
+
+    testing:
+        runs-on: ubuntu-20.04
+        needs: [ conan-recipe-version ]
+
+        steps:
+            -   name: Checkout
+                uses: actions/checkout@v3
+                with:
+                    fetch-depth: 2
+
+            -   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: 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: Use Conan download cache (Bash)
+                if: ${{ runner.os != 'Windows' }}
+                run: conan config set storage.download_cache="$HOME/.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 }}-unit-cache
+
+            -   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: 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 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: 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: 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: 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

.gitignore

@@ -38,6 +38,7 @@ cura.desktop
 .settings
 
 #Externally located plug-ins commonly installed by our devs.
+plugins/BarbarianPlugin
 plugins/cura-big-flame-graph
 plugins/cura-camera-position
 plugins/cura-god-mode-plugin
@@ -64,6 +65,7 @@ plugins/CuraRemoteSupport
 plugins/ModelCutter
 plugins/PrintProfileCreator
 plugins/MultiPrintPlugin
+plugins/CuraOrientationPlugin
 
 #Build stuff
 CMakeCache.txt
@@ -87,4 +89,14 @@ CuraEngine
 #Prevents import failures when plugin running tests
 plugins/__init__.py
 
-/venv
+venv/
+build/
+dist/
+conaninfo.txt
+conan.lock
+conan_imports_manifest.txt
+conanbuildinfo.txt
+graph_info.json
+Ultimaker-Cura.spec
+.run/
+/printer-linter/src/printerlinter.egg-info/

.printer-linter

@@ -0,0 +1,15 @@
+checks:
+    diagnostic-mesh-file-extension: true
+    diagnostic-mesh-file-size: true
+    diagnostic-definition-redundant-override: true
+fixes:
+    diagnostic-definition-redundant-override: true
+format:
+    format-definition-bracket-newline: true
+    format-definition-paired-coordinate-array: true
+    format-definition-sort-keys: true
+    format-definition-indent: 4
+    format-definition-single-value-single-line: true # Format dicts and lists with a single item on one line "dict": { "value": 10 }
+    format-profile-space-around-delimiters: true
+    format-profile-sort-keys: true
+diagnostic-mesh-file-size: 1200000

.run_templates/pycharm_cura_run.run.xml.jinja

@@ -0,0 +1,25 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="{{ name }}" type="PythonConfigurationType" factoryName="Python" nameIsGenerated="true">
+    <module name="{{ module_name }}" />
+    <option name="INTERPRETER_OPTIONS" value="" />
+    <option name="PARENT_ENVS" value="true" />
+    <envs>
+      <env name="PYTHONUNBUFFERED" value="1" />{% for key, value in env_vars.items() %}
+      <env name="{{ key }}" value="{{ value }}" />{% endfor %}
+    </envs>
+    <option name="SDK_HOME" value="{{ sdk_path }}" />
+    <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$" />
+    <option name="IS_MODULE_SDK" value="true" />
+    <option name="ADD_CONTENT_ROOTS" value="true" />
+    <option name="ADD_SOURCE_ROOTS" value="true" />
+    <EXTENSION ID="PythonCoverageRunConfigurationExtension" runner="coverage.py" />
+    <option name="SCRIPT_NAME" value="$PROJECT_DIR$/{{ script_name }}" />
+    <option name="PARAMETERS" value="{{ parameters }}" />
+    <option name="SHOW_COMMAND_LINE" value="false" />
+    <option name="EMULATE_TERMINAL" value="false" />
+    <option name="MODULE_MODE" value="false" />
+    <option name="REDIRECT_INPUT" value="false" />
+    <option name="INPUT_FILE" value="" />
+    <method v="2" />
+  </configuration>
+</component>

.run_templates/pycharm_cura_test.run.xml.jinja

@@ -0,0 +1,23 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="{{ name }}"  type="tests" factoryName="py.test" nameIsGenerated="true">
+    <module name="{{ module_name }}" />
+    <option name="INTERPRETER_OPTIONS" value="" />
+    <option name="PARENT_ENVS" value="true" />
+    <envs>
+      <env name="PYTHONUNBUFFERED" value="1" />{% for key, value in env_vars.items() %}
+      <env name="{{ key }}" value="{{ value }}" />{% endfor %}
+    </envs>
+    <option name="SDK_HOME" value="{{ sdk_path }}" />
+    <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$/tests" />
+    <option name="IS_MODULE_SDK" value="true" />
+    <option name="ADD_CONTENT_ROOTS" value="true" />
+    <option name="ADD_SOURCE_ROOTS" value="true" />
+    <EXTENSION ID="PythonCoverageRunConfigurationExtension" runner="coverage.py" />
+    <option name="_new_keywords" value="&quot;&quot;" />
+    <option name="_new_parameters" value="&quot;&quot;" />
+    <option name="_new_additionalArguments" value="&quot;&quot;" />
+    <option name="_new_target" value="&quot;$PROJECT_DIR$/{{ script_name }}&quot;" />
+    <option name="_new_targetType" value="&quot;PATH&quot;" />
+    <method v="2" />
+  </configuration>
+</component>

CITATION.cff

@@ -1,11 +1,30 @@
 # YAML 1.2
 ---
-authors: 
-cff-version: "1.1.0"
-date-released: 2021-06-28
-license: "LGPL-3.0"
-message: "If you use this software, please cite it using these metadata."
-repository-code: "https://github.com/ultimaker/cura/"
-title: "Ultimaker Cura"
-version: "4.12.0"
-...
+cff-version: 1.2.0
+type: software
+message: >-
+  If you use this software, please cite it using the
+  metadata from this file.
+title: Ultimaker Cura
+abstract: >-
+  A state-of-the-art slicer application built on top
+  of the Uranium framework.
+authors:
+  - name: Ultimaker B.V.
+contact:
+  - email: info@ultimaker.com
+    name: "Ultimaker B.V."
+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"
+keywords:
+  - Ultimaker
+  - Cura
+  - Slicer
+  - Uranium
+  - Arachne
+  - 3D Printing
+  - Additive Manufacturing

CMakeLists.txt

@@ -1,5 +1,12 @@
+# Copyright (c) 2022 Ultimaker B.V.
+# Cura is released under the terms of the LGPLv3 or higher.
+
+# NOTE: This is only being used for translation scripts.
+
+# For MSVC flags, will be ignored on non-Windows OS's and this project in general. Only needed for cura-build-environment.
+cmake_policy(SET CMP0091 NEW)
 project(cura)
-cmake_minimum_required(VERSION 3.6)
+cmake_minimum_required(VERSION 3.18)
 
 include(GNUInstallDirs)
 
@@ -8,42 +15,8 @@ list(APPEND CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake)
 set(URANIUM_DIR "${CMAKE_SOURCE_DIR}/../Uranium" CACHE PATH "The location of the Uranium repository")
 set(URANIUM_SCRIPTS_DIR "${URANIUM_DIR}/scripts" CACHE PATH "The location of the scripts directory of the Uranium repository")
 
-# Tests
-include(CuraTests)
-
-option(CURA_DEBUGMODE "Enable debug dialog and other debug features" OFF)
-if(CURA_DEBUGMODE)
-    set(_cura_debugmode "ON")
-endif()
-
 option(GENERATE_TRANSLATIONS "Should the translations be generated?" ON)
 
-set(CURA_APP_NAME "cura" CACHE STRING "Short name of Cura, used for configuration folder")
-set(CURA_APP_DISPLAY_NAME "Ultimaker Cura" CACHE STRING "Display name of Cura")
-set(CURA_VERSION "master" CACHE STRING "Version name of Cura")
-set(CURA_BUILDTYPE "" CACHE STRING "Build type of Cura, eg. 'PPA'")
-set(CURA_CLOUD_API_ROOT "" CACHE STRING "Alternative Cura cloud API root")
-set(CURA_CLOUD_API_VERSION "" CACHE STRING "Alternative Cura cloud API version")
-set(CURA_CLOUD_ACCOUNT_API_ROOT "" CACHE STRING "Alternative Cura cloud account API version")
-set(CURA_MARKETPLACE_ROOT "" CACHE STRING "Alternative Marketplace location")
-set(CURA_DIGITAL_FACTORY_URL "" CACHE STRING "Alternative Digital Factory location")
-
-configure_file(${CMAKE_SOURCE_DIR}/com.ultimaker.cura.desktop.in ${CMAKE_BINARY_DIR}/com.ultimaker.cura.desktop @ONLY)
-
-configure_file(cura/CuraVersion.py.in CuraVersion.py @ONLY)
-
-
-# FIXME: The new FindPython3 finds the system's Python3.6 rather than the Python3.5 that we built for Cura's environment.
-# So we're using the old method here, with FindPythonInterp for now.
-find_package(PythonInterp 3 REQUIRED)
-
-set(Python3_EXECUTABLE ${PYTHON_EXECUTABLE})
-
-set(Python3_VERSION ${PYTHON_VERSION_STRING})
-set(Python3_VERSION_MAJOR ${PYTHON_VERSION_MAJOR})
-set(Python3_VERSION_MINOR ${PYTHON_VERSION_MINOR})
-set(Python3_VERSION_PATCH ${PYTHON_VERSION_PATCH})
-
 if(NOT ${URANIUM_DIR} STREQUAL "")
     set(CMAKE_MODULE_PATH "${CMAKE_MODULE_PATH};${URANIUM_DIR}/cmake")
 endif()
@@ -56,48 +29,4 @@ if(NOT ${URANIUM_SCRIPTS_DIR} STREQUAL "")
     if(${GENERATE_TRANSLATIONS})
         CREATE_TRANSLATION_TARGETS()
     endif()
-endif()
-
-
-install(DIRECTORY resources
-        DESTINATION ${CMAKE_INSTALL_DATADIR}/cura)
-
-include(CuraPluginInstall)
-
-if(NOT APPLE AND NOT WIN32)
-    install(FILES cura_app.py
-            DESTINATION ${CMAKE_INSTALL_BINDIR}
-            PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE
-            RENAME cura)
-    if(EXISTS /etc/debian_version)
-        install(DIRECTORY cura
-            DESTINATION lib${LIB_SUFFIX}/python${Python3_VERSION_MAJOR}/dist-packages
-            FILES_MATCHING PATTERN *.py)
-        install(FILES ${CMAKE_BINARY_DIR}/CuraVersion.py
-            DESTINATION lib${LIB_SUFFIX}/python${Python3_VERSION_MAJOR}/dist-packages/cura)
-    else()
-        install(DIRECTORY cura
-            DESTINATION lib${LIB_SUFFIX}/python${Python3_VERSION_MAJOR}.${Python3_VERSION_MINOR}/site-packages
-            FILES_MATCHING PATTERN *.py)
-        install(FILES ${CMAKE_BINARY_DIR}/CuraVersion.py
-            DESTINATION lib${LIB_SUFFIX}/python${Python3_VERSION_MAJOR}.${Python3_VERSION_MINOR}/site-packages/cura)
-    endif()
-    install(FILES ${CMAKE_BINARY_DIR}/com.ultimaker.cura.desktop
-            DESTINATION ${CMAKE_INSTALL_DATADIR}/applications)
-    install(FILES ${CMAKE_SOURCE_DIR}/resources/images/cura-icon.png
-            DESTINATION ${CMAKE_INSTALL_DATADIR}/icons/hicolor/128x128/apps/)
-    install(FILES com.ultimaker.cura.appdata.xml
-            DESTINATION ${CMAKE_INSTALL_DATADIR}/metainfo)
-    install(FILES cura.sharedmimeinfo
-            DESTINATION ${CMAKE_INSTALL_DATADIR}/mime/packages/
-            RENAME cura.xml )
-else()
-    install(FILES cura_app.py
-            DESTINATION ${CMAKE_INSTALL_BINDIR}
-            PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE)
-    install(DIRECTORY cura
-            DESTINATION lib${LIB_SUFFIX}/python${Python3_VERSION_MAJOR}.${Python3_VERSION_MINOR}/site-packages
-            FILES_MATCHING PATTERN *.py)
-    install(FILES ${CMAKE_BINARY_DIR}/CuraVersion.py
-            DESTINATION lib${LIB_SUFFIX}/python${Python3_VERSION_MAJOR}.${Python3_VERSION_MINOR}/site-packages/cura)
-endif()
+endif()

CuraVersion.py.jinja

@@ -0,0 +1,14 @@
+# Copyright (c) 2022 UltiMaker
+# Cura is released under the terms of the LGPLv3 or higher.
+
+CuraAppName = "{{ cura_app_name }}"
+CuraAppDisplayName = "{{ cura_app_display_name  }}"
+CuraVersion = "{{ cura_version }}"
+CuraBuildType = "{{ cura_build_type }}"
+CuraDebugMode = {{ cura_debug_mode }}
+CuraCloudAPIRoot = "{{ cura_cloud_api_root }}"
+CuraCloudAPIVersion = "{{ cura_cloud_api_version }}"
+CuraCloudAccountAPIRoot = "{{ cura_cloud_account_api_root }}"
+CuraMarketplaceRoot = "{{ cura_marketplace_root }}"
+CuraDigitalFactoryURL = "{{ cura_digital_factory_url }}"
+CuraLatestURL = "{{ cura_latest_url }}"

Dockerfile

@@ -1,45 +0,0 @@
-FROM ultimaker/cura-build-environment:1
-
-# Environment vars for easy configuration
-ENV CURA_APP_DIR=/srv/cura
-
-# Ensure our sources dir exists
-RUN mkdir $CURA_APP_DIR
-
-# Setup CuraEngine
-ENV CURA_ENGINE_BRANCH=master
-WORKDIR $CURA_APP_DIR
-RUN git clone -b $CURA_ENGINE_BRANCH --depth 1 https://github.com/Ultimaker/CuraEngine
-WORKDIR $CURA_APP_DIR/CuraEngine
-RUN mkdir build
-WORKDIR $CURA_APP_DIR/CuraEngine/build
-RUN cmake3 ..
-RUN make
-RUN make install
-
-# TODO: setup libCharon
-
-# Setup Uranium
-ENV URANIUM_BRANCH=master
-WORKDIR $CURA_APP_DIR
-RUN git clone -b $URANIUM_BRANCH --depth 1 https://github.com/Ultimaker/Uranium
-
-# Setup materials
-ENV MATERIALS_BRANCH=master
-WORKDIR $CURA_APP_DIR
-RUN git clone -b $MATERIALS_BRANCH --depth 1 https://github.com/Ultimaker/fdm_materials materials
-
-# Setup Cura
-WORKDIR $CURA_APP_DIR/Cura
-ADD . .
-RUN mv $CURA_APP_DIR/materials resources/materials
-
-# Make sure Cura can find CuraEngine
-RUN ln -s /usr/local/bin/CuraEngine $CURA_APP_DIR/Cura
-
-# Run Cura
-WORKDIR $CURA_APP_DIR/Cura
-ENV PYTHONPATH=${PYTHONPATH}:$CURA_APP_DIR/Uranium
-RUN chmod +x ./CuraEngine
-RUN chmod +x ./run_in_docker.sh
-CMD "./run_in_docker.sh"

Jenkinsfile

@@ -1,74 +0,0 @@
-parallel_nodes(['linux && cura', 'windows && cura'])
-{
-    timeout(time: 2, unit: "HOURS")
-    {
-
-        // Prepare building
-        stage('Prepare')
-        {
-            // Ensure we start with a clean build directory.
-            step([$class: 'WsCleanup'])
-
-            // Checkout whatever sources are linked to this pipeline.
-            checkout scm
-        }
-
-        // If any error occurs during building, we want to catch it and continue with the "finale" stage.
-        catchError
-        {
-            // Building and testing should happen in a subdirectory.
-            dir('build')
-            {
-                // Perform the "build". Since Uranium is Python code, this basically only ensures CMake is setup.
-                stage('Build')
-                {
-                    def branch = env.BRANCH_NAME
-                    if(!fileExists("${env.CURA_ENVIRONMENT_PATH}/${branch}"))
-                    {
-                        branch = "master"
-                    }
-
-                    // Ensure CMake is setup. Note that since this is Python code we do not really "build" it.
-                    def uranium_dir = get_workspace_dir("Ultimaker/Uranium/${branch}")
-                    cmake("..", "-DCMAKE_PREFIX_PATH=\"${env.CURA_ENVIRONMENT_PATH}/${branch}\" -DCMAKE_BUILD_TYPE=Release -DURANIUM_DIR=\"${uranium_dir}\"")
-                }
-
-                // Try and run the unit tests. If this stage fails, we consider the build to be "unstable".
-                stage('Unit Test')
-                {
-                    if (isUnix())
-                    {
-                        // For Linux
-                        try {
-                            sh 'make CTEST_OUTPUT_ON_FAILURE=TRUE test'
-                        } catch(e)
-                        {
-                            currentBuild.result = "UNSTABLE"
-                        }
-                    }
-                    else
-                    {
-                        // For Windows
-                        try
-                        {
-                            // This also does code style checks.
-                            bat 'ctest -V'
-                        } catch(e)
-                        {
-                            currentBuild.result = "UNSTABLE"
-                        }
-                    }
-                }
-            }
-        }
-
-        // Perform any post-build actions like notification and publishing of unit tests.
-        stage('Finalize')
-        {
-            // Publish the test results to Jenkins.
-            junit allowEmptyResults: true, testResults: 'build/junit*.xml'
-
-            notify_build_result(env.CURA_EMAIL_RECIPIENTS, '#cura-dev', ['master', '2.'])
-        }
-    }
-}

README.md

@@ -1,61 +1,96 @@
-Cura
-====
-Ultimaker Cura is a state-of-the-art slicer application to prepare your 3D models for printing with a 3D printer. With hundreds of settings and hundreds of community-managed print profiles, Ultimaker Cura is sure to lead your next project to a success.
 
-![Screenshot](cura-logo.PNG)
+<br>
 
-Logging Issues
-------------
-For crashes and similar issues, please attach the following information:
+<div align = center>
 
-* (On Windows) The log as produced by dxdiag (start -> run -> dxdiag -> save output)
-* The Cura GUI log file, located at
-  * `%APPDATA%\cura\<Cura version>\cura.log` (Windows), or usually `C:\Users\<your username>\AppData\Roaming\cura\<Cura version>\cura.log`
-  * `$HOME/Library/Application Support/cura/<Cura version>/cura.log` (OSX)
-  * `$HOME/.local/share/cura/<Cura version>/cura.log` (Ubuntu/Linux)
+[![Badge Issues]][Issues]   
+[![Badge PullRequests]][PullRequests]   
+[![Badge Closed]][Closed]
 
-If the Cura user interface still starts, you can also reach this directory from the application menu in Help -> Show settings folder
+[![Badge Size]][#]   
+[![Badge License]][License]   
+[![Badge Contributors]][Contributors]
 
-For additional support, you could also ask in the [#cura channel](https://web.libera.chat/#cura) on [libera.chat](https://libera.chat/). For help with development, there is also the [#cura-dev channel](https://web.libera.chat/#cura-dev).
+[![Badge Test]][Test]   
+[![Badge Conan]][Conan]   
 
-Dependencies
-------------
-* [Uranium](https://github.com/Ultimaker/Uranium) Cura is built on top of the Uranium framework.
-* [CuraEngine](https://github.com/Ultimaker/CuraEngine) This will be needed at runtime to perform the actual slicing.
-* [fdm_materials](https://github.com/Ultimaker/fdm_materials) Required to load a printer that has swappable material profiles.
-* [PySerial](https://github.com/pyserial/pyserial) Only required for USB printing support.
-* [python-zeroconf](https://github.com/jstasiak/python-zeroconf) Only required to detect mDNS-enabled printers.
+<br>
+<br>
 
-For a list of required Python packages, with their recommended version, see `requirements.txt`.
+![Logo]
 
-This list is not exhaustive at the moment, please check the links in the next section for more details.
+# Ultimaker Cura
 
-Build scripts
--------------
-Please check out [cura-build](https://github.com/Ultimaker/cura-build) for detailed building instructions.
+*State-of-the-art slicer app to prepare* <br>
+*your 3D models for your 3D printer.*
 
-If you want to build the entire environment from scratch before building Cura as well, [cura-build-environment](https://github.com/Ultimaker/cura-build-environment) might be a starting point before cura-build. (Again, see cura-build for more details.)
+*With hundreds of settings & community-managed print profiles,* <br>
+*Ultimaker Cura is sure to lead your next project to a success.*
 
-Running from Source
--------------
-Please check our [Wiki page](https://github.com/Ultimaker/Cura/wiki/Running-Cura-from-Source) for details about running Cura from source.
+<br>
+<br>
 
-Plugins
--------------
-Please check our [Wiki page](https://github.com/Ultimaker/Cura/wiki/Plugin-Directory) for details about creating and using plugins.
+[![Button Building]][Building]   
+[![Button Plugins]][Plugins]   
+[![Button Machines]][Machines]
 
-Supported printers
--------------
-Please check our [Wiki page](https://github.com/Ultimaker/Cura/wiki/Adding-new-machine-profiles-to-Cura) for guidelines about adding support for new machines.
+[![Button Report]][Report]   
+[![Button Settings]][Settings]   
+[![Button Localize]][Localize]
 
-Configuring Cura
-----------------
-Please check out [Wiki page](https://github.com/Ultimaker/Cura/wiki/Cura-Settings) about configuration options for developers.
+<br>
+<br>
+
+<picture>
+  <source media="(prefers-color-scheme: light)" srcset="./cura-logo.PNG">
+  <source media="(prefers-color-scheme: dark)" srcset="./cura-logo-dark.PNG">
+  <img alt="Shows cura open on the preview screen with a large benchy model in the center." src="./cura-logo.PNG">
+</picture>
+
+</div>
+
+<br>
+
+
+<!----------------------------------------------------------------------------->
+
+[Contributors]: https://github.com/Ultimaker/Cura/graphs/contributors
+[PullRequests]: https://github.com/Ultimaker/Cura/pulls
+[Machines]: https://github.com/Ultimaker/Cura/wiki/Adding-new-machine-profiles-to-Cura
+[Building]: https://github.com/Ultimaker/Cura/wiki/Running-Cura-from-Source
+[Localize]: https://github.com/Ultimaker/Cura/wiki/Translating-Cura
+[Settings]: https://github.com/Ultimaker/Cura/wiki/Cura-Settings
+[Plugins]: https://github.com/Ultimaker/Cura/wiki/Plugin-Directory
+[Closed]: https://github.com/Ultimaker/Cura/issues?q=is%3Aissue+is%3Aclosed
+[Issues]: https://github.com/Ultimaker/Cura/issues
+[Conan]: https://github.com/Ultimaker/Cura/actions/workflows/conan-package.yml
+[Test]: https://github.com/Ultimaker/Cura/actions/workflows/unit-test.yml
+
+[License]: LICENSE
+[Report]: docs/Report.md
+[Logo]: resources/images/cura-icon.png
+[#]: #
+
+
+<!---------------------------------[ Badges ]---------------------------------->
+
+[Badge Contributors]: https://img.shields.io/github/contributors/ultimaker/cura?style=for-the-badge&logoColor=white&labelColor=db5e8a&color=ab4a6c&logo=GitHub
+[Badge PullRequests]: https://img.shields.io/github/issues-pr/ultimaker/cura?style=for-the-badge&logoColor=white&labelColor=bb9f3e&color=937d31&logo=GitExtensions
+[Badge License]: https://img.shields.io/badge/License-LGPL3-336887.svg?style=for-the-badge&labelColor=458cb5&logoColor=white&logo=GNU
+[Badge Closed]: https://img.shields.io/github/issues-closed/ultimaker/cura?style=for-the-badge&logoColor=white&labelColor=629944&color=446a30&logo=AddThis
+[Badge Issues]: https://img.shields.io/github/issues/ultimaker/cura?style=for-the-badge&logoColor=white&labelColor=c34360&color=933349&logo=AdBlock
+[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
+
+
+<!---------------------------------[ Buttons ]--------------------------------->
+
+[Button Localize]: https://img.shields.io/badge/Help_Localize-e2467d?style=for-the-badge&logoColor=white&logo=GoogleTranslate
+[Button Machines]: https://img.shields.io/badge/Adding_Machines-yellow?style=for-the-badge&logoColor=white&logo=CloudFoundry
+[Button Settings]: https://img.shields.io/badge/Configuration-00979D?style=for-the-badge&logoColor=white&logo=CodeReview
+[Button Building]: https://img.shields.io/badge/Building_Cura-blue?style=for-the-badge&logoColor=white&logo=GitBook
+[Button Plugins]: https://img.shields.io/badge/Plugin_Usage-569A31?style=for-the-badge&logoColor=white&logo=ROS
+[Button Report]: https://img.shields.io/badge/Report_Issues-C9284D?style=for-the-badge&logoColor=white&logo=Cliqz
 
-Translating Cura
-----------------
-Please check out [Wiki page](https://github.com/Ultimaker/Cura/wiki/Translating-Cura) about how to translate Cura into other languages.
 
-License
-----------------
-Cura is released under the terms of the LGPLv3 or higher. A copy of this license should be included with the software.

SECURITY.md

@@ -0,0 +1,5 @@
+# Reporting vulnerabilities
+
+If you discover a vulnerability, please let us know as soon as possible via `security@ultimaker.com`.
+Please do not take advantage of the vulnerability and do not reveal the problem to others.
+To allow us to resolve the issue, please do provide us with sufficient information to reproduce the problem.

UltiMaker-Cura.spec.jinja

@@ -0,0 +1,273 @@
+# -*- mode: python ; coding: utf-8 -*-
+import os
+from pathlib import Path
+from PyInstaller.utils.hooks import collect_all
+
+
+datas = {{ datas }}
+binaries = {{ binaries }}
+
+hiddenimports = {{ hiddenimports }}
+
+{% for value in collect_all %}tmp_ret = collect_all('{{ value }}')
+datas += tmp_ret[0]; binaries += tmp_ret[1]; hiddenimports += tmp_ret[2]
+{% endfor %}
+
+# Add dynamic libs in the venv bin/Script Path. This is needed because we might copy some additional libs
+# e.q.: OpenSSL 1.1.1l in that directory with a separate:
+# `conan install openssl@1.1.1l -g deploy && cp openssl/bin/*.so cura_inst/bin`
+binaries.extend([(str(bin), ".") for bin in Path("{{ venv_script_path }}").glob("*.so*")])
+binaries.extend([(str(bin), ".") for bin in Path("{{ venv_script_path }}").glob("*.dll")])
+binaries.extend([(str(bin), ".") for bin in Path("{{ venv_script_path }}").glob("*.dylib")])
+
+block_cipher = None
+
+a = Analysis(
+    [{{ entrypoint }}],
+    pathex=[],
+    binaries=binaries,
+    datas=datas,
+    hiddenimports=hiddenimports,
+    hookspath=[],
+    hooksconfig={},
+    runtime_hooks=[],
+    excludes=[],
+    win_no_prefer_redirects=False,
+    win_private_assemblies=False,
+    cipher=block_cipher,
+    noarchive=False
+)
+pyz = PYZ(a.pure, a.zipped_data, cipher=block_cipher)
+
+exe = EXE(
+    pyz,
+    a.scripts,
+    [],
+    exclude_binaries=True,
+    name=r'{{ name }}',
+    debug=False,
+    bootloader_ignore_signals=False,
+    strip={{ strip }},
+    upx={{ upx }},
+    console=False,
+    disable_windowed_traceback=False,
+    argv_emulation=False,
+    target_arch={{ target_arch }},
+    codesign_identity=os.getenv('CODESIGN_IDENTITY', None),
+    entitlements_file={{ entitlements_file }},
+    icon={{ icon }}
+)
+
+coll = COLLECT(
+    exe,
+    a.binaries,
+    a.zipfiles,
+    a.datas,
+    strip=False,
+    upx=True,
+    upx_exclude=[],
+    name=r'{{ name }}'
+)
+
+{% if macos == true %}
+# PyInstaller seems to copy everything in the resource folder for the MacOS, this causes issues with codesigning and notarizing
+# The folder structure should adhere to the one specified in Table 2-5
+# https://developer.apple.com/library/archive/documentation/CoreFoundation/Conceptual/CFBundles/BundleTypes/BundleTypes.html#//apple_ref/doc/uid/10000123i-CH101-SW1
+# The class below is basically ducktyping the BUNDLE class of PyInstaller and using our own `assemble` method for more fine-grain and specific
+# control. Some code of the method below is copied from:
+# https://github.com/pyinstaller/pyinstaller/blob/22d1d2a5378228744cc95f14904dae1664df32c4/PyInstaller/building/osx.py#L115
+#-----------------------------------------------------------------------------
+# Copyright (c) 2005-2022, PyInstaller Development Team.
+#
+# Distributed under the terms of the GNU General Public License (version 2
+# or later) with exception for distributing the bootloader.
+#
+# The full license is in the file COPYING.txt, distributed with this software.
+#
+# SPDX-License-Identifier: (GPL-2.0-or-later WITH Bootloader-exception)
+#-----------------------------------------------------------------------------
+
+import plistlib
+import shutil
+import PyInstaller.utils.osx as osxutils
+from pathlib import Path
+from PyInstaller.building.osx import BUNDLE
+from PyInstaller.building.utils import (_check_path_overlap, _rmtree, add_suffix_to_extension, checkCache)
+from PyInstaller.building.datastruct import logger
+from PyInstaller.building.icon import normalize_icon_type
+
+
+class UMBUNDLE(BUNDLE):
+    def assemble(self):
+        from PyInstaller.config import CONF
+
+        if _check_path_overlap(self.name) and os.path.isdir(self.name):
+            _rmtree(self.name)
+        logger.info("Building BUNDLE %s", self.tocbasename)
+
+        # Create a minimal Mac bundle structure.
+        macos_path = Path(self.name, "Contents", "MacOS")
+        resources_path = Path(self.name, "Contents", "Resources")
+        frameworks_path = Path(self.name, "Contents", "Frameworks")
+        os.makedirs(macos_path)
+        os.makedirs(resources_path)
+        os.makedirs(frameworks_path)
+
+        # Makes sure the icon exists and attempts to convert to the proper format if applicable
+        self.icon = normalize_icon_type(self.icon, ("icns",), "icns", CONF["workpath"])
+
+        # Ensure icon path is absolute
+        self.icon = os.path.abspath(self.icon)
+
+        # Copy icns icon to Resources directory.
+        shutil.copy(self.icon, os.path.join(self.name, 'Contents', 'Resources'))
+
+        # Key/values for a minimal Info.plist file
+        info_plist_dict = {
+            "CFBundleDisplayName": self.appname,
+            "CFBundleName": self.appname,
+
+            # Required by 'codesign' utility.
+            # The value for CFBundleIdentifier is used as the default unique name of your program for Code Signing
+            # purposes. It even identifies the APP for access to restricted OS X areas like Keychain.
+            #
+            # The identifier used for signing must be globally unique. The usual form for this identifier is a
+            # hierarchical name in reverse DNS notation, starting with the toplevel domain, followed by the company
+            # name, followed by the department within the company, and ending with the product name. Usually in the
+            # form: com.mycompany.department.appname
+            # CLI option --osx-bundle-identifier sets this value.
+            "CFBundleIdentifier": self.bundle_identifier,
+            "CFBundleExecutable": os.path.basename(self.exename),
+            "CFBundleIconFile": os.path.basename(self.icon),
+            "CFBundleInfoDictionaryVersion": "6.0",
+            "CFBundlePackageType": "APPL",
+            "CFBundleShortVersionString": self.version,
+        }
+
+        # Set some default values. But they still can be overwritten by the user.
+        if self.console:
+            # Setting EXE console=True implies LSBackgroundOnly=True.
+            info_plist_dict['LSBackgroundOnly'] = True
+        else:
+            # Let's use high resolution by default.
+            info_plist_dict['NSHighResolutionCapable'] = True
+
+        # Merge info_plist settings from spec file
+        if isinstance(self.info_plist, dict) and self.info_plist:
+            info_plist_dict.update(self.info_plist)
+
+        plist_filename = os.path.join(self.name, "Contents", "Info.plist")
+        with open(plist_filename, "wb") as plist_fh:
+            plistlib.dump(info_plist_dict, plist_fh)
+
+        links = []
+        _QT_BASE_PATH = {'PySide2', 'PySide6', 'PyQt5', 'PyQt6', 'PySide6'}
+        for inm, fnm, typ in self.toc:
+            # Adjust name for extensions, if applicable
+            inm, fnm, typ = add_suffix_to_extension(inm, fnm, typ)
+            inm = Path(inm)
+            fnm = Path(fnm)
+            # Copy files from cache. This ensures that are used files with relative paths to dynamic library
+            # dependencies (@executable_path)
+            if typ in ('EXTENSION', 'BINARY') or (typ == 'DATA' and inm.suffix == '.so'):
+                if any(['.' in p for p in inm.parent.parts]):
+                    inm = Path(inm.name)
+                fnm = Path(checkCache(
+                    str(fnm),
+                    strip = self.strip,
+                    upx = self.upx,
+                    upx_exclude = self.upx_exclude,
+                    dist_nm = str(inm),
+                    target_arch = self.target_arch,
+                    codesign_identity = self.codesign_identity,
+                    entitlements_file = self.entitlements_file,
+                    strict_arch_validation = (typ == 'EXTENSION'),
+                ))
+                frame_dst = frameworks_path.joinpath(inm)
+                if not frame_dst.exists():
+                    if frame_dst.is_dir():
+                        os.makedirs(frame_dst, exist_ok = True)
+                    else:
+                        os.makedirs(frame_dst.parent, exist_ok = True)
+                shutil.copy(fnm, frame_dst, follow_symlinks = True)
+                macos_dst = macos_path.joinpath(inm)
+                if not macos_dst.exists():
+                    if macos_dst.is_dir():
+                        os.makedirs(macos_dst, exist_ok = True)
+                    else:
+                        os.makedirs(macos_dst.parent, exist_ok = True)
+
+                    # Create relative symlink to the framework
+                    symlink_to = Path(*[".." for p in macos_dst.relative_to(macos_path).parts], "Frameworks").joinpath(
+                        frame_dst.relative_to(frameworks_path))
+                    try:
+                        macos_dst.symlink_to(symlink_to)
+                    except FileExistsError:
+                        pass
+            else:
+                if typ == 'DATA':
+                    if any(['.' in p for p in inm.parent.parts]) or inm.suffix == '.so':
+                        # Skip info dist egg and some not needed folders in tcl and tk, since they all contain dots in their files
+                        logger.warning(f"Skipping DATA file {inm}")
+                        continue
+                    res_dst = resources_path.joinpath(inm)
+                    if not res_dst.exists():
+                        if res_dst.is_dir():
+                            os.makedirs(res_dst, exist_ok = True)
+                        else:
+                            os.makedirs(res_dst.parent, exist_ok = True)
+                    shutil.copy(fnm, res_dst, follow_symlinks = True)
+                    macos_dst = macos_path.joinpath(inm)
+                    if not macos_dst.exists():
+                        if macos_dst.is_dir():
+                            os.makedirs(macos_dst, exist_ok = True)
+                        else:
+                            os.makedirs(macos_dst.parent, exist_ok = True)
+
+                        # Create relative symlink to the resource
+                        symlink_to = Path(*[".." for p in macos_dst.relative_to(macos_path).parts], "Resources").joinpath(
+                            res_dst.relative_to(resources_path))
+                        try:
+                            macos_dst.symlink_to(symlink_to)
+                        except FileExistsError:
+                            pass
+                else:
+                    macos_dst = macos_path.joinpath(inm)
+                    if not macos_dst.exists():
+                        if macos_dst.is_dir():
+                            os.makedirs(macos_dst, exist_ok = True)
+                        else:
+                            os.makedirs(macos_dst.parent, exist_ok = True)
+                        shutil.copy(fnm, macos_dst, follow_symlinks = True)
+
+        # Sign the bundle
+        logger.info('Signing the BUNDLE...')
+        try:
+            osxutils.sign_binary(self.name, self.codesign_identity, self.entitlements_file, deep = True)
+        except Exception as e:
+            logger.warning(f"Error while signing the bundle: {e}")
+            logger.warning("You will need to sign the bundle manually!")
+
+        logger.info(f"Building BUNDLE {self.tocbasename} completed successfully.")
+
+app = UMBUNDLE(
+    coll,
+    name='{{ name }}.app',
+    icon={{ icon }},
+    bundle_identifier={{ osx_bundle_identifier }},
+    version={{ version }},
+    info_plist={
+        'CFBundleDisplayName': '{{ display_name }}',
+        'NSPrincipalClass': 'NSApplication',
+        'CFBundleDevelopmentRegion': 'English',
+        'CFBundleExecutable': '{{ name }}',
+        'CFBundleInfoDictionaryVersion': '6.0',
+        'CFBundlePackageType': 'APPL',
+        'CFBundleShortVersionString': {{ short_version }},
+        'CFBundleDocumentTypes': [{
+                'CFBundleTypeRole': 'Viewer',
+                'CFBundleTypeExtensions': ['*'],
+                'CFBundleTypeName': 'Model Files',
+            }]
+        },
+){% endif %}

build.sh

@@ -1,34 +0,0 @@
-set -e
-set -u
-
-export OLD_PWD=`pwd`
-export CMAKE=/c/software/PCL/cmake-3.0.1-win32-x86/bin/cmake.exe
-export MAKE=mingw32-make.exe
-export PATH=/c/mingw-w64/i686-4.9.2-posix-dwarf-rt_v3-rev1/mingw32/bin:$PATH
-
-mkdir -p /c/software/protobuf/_build
-cd /c/software/protobuf/_build
-$CMAKE ../
-$MAKE install
-
-mkdir -p /c/software/libArcus/_build
-cd /c/software/libArcus/_build
-$CMAKE ../
-$MAKE install
-
-mkdir -p /c/software/PinkUnicornEngine/_build
-cd /c/software/PinkUnicornEngine/_build
-$CMAKE ../
-$MAKE
-
-cd $OLD_PWD
-export PYTHONPATH=`pwd`/../libArcus/python:/c/Software/Uranium/
-/c/python34/python setup.py py2exe
-
-cp /c/software/PinkUnicornEngine/_build/CuraEngine.exe dist/
-cp /c/software/libArcus/_install/bin/libArcus.dll dist/
-cp /c/mingw-w64/i686-4.9.2-posix-dwarf-rt_v3-rev1/mingw32/bin/libgcc_s_dw2-1.dll dist/
-cp /c/mingw-w64/i686-4.9.2-posix-dwarf-rt_v3-rev1/mingw32/bin/libwinpthread-1.dll dist/
-cp /c/mingw-w64/i686-4.9.2-posix-dwarf-rt_v3-rev1/mingw32/bin/libstdc++-6.dll dist/
-
-/c/program\ files\ \(x86\)/NSIS/makensis.exe installer.nsi

cmake/CuraPluginInstall.cmake

@@ -1,105 +0,0 @@
-# Copyright (c) 2019 Ultimaker B.V.
-# CuraPluginInstall.cmake is released under the terms of the LGPLv3 or higher.
-
-#
-# This module detects all plugins that need to be installed and adds them using the CMake install() command.
-# It detects all plugin folder in the path "plugins/*" where there's a "plugin.json" in it.
-#
-# Plugins can be configured to NOT BE INSTALLED via the variable "CURA_NO_INSTALL_PLUGINS" as a list of string in the
-# form of "a;b;c" or "a,b,c". By default all plugins will be installed.
-#
-
-option(PRINT_PLUGIN_LIST "Should the list of plugins that are installed be printed?" ON)
-
-# FIXME: Remove the code for CMake <3.12 once we have switched over completely.
-# FindPython3 is a new module since CMake 3.12. It deprecates FindPythonInterp and FindPythonLibs. The FindPython3
-# module is copied from the CMake repository here so in CMake <3.12 we can still use it.
-if(${CMAKE_VERSION} VERSION_LESS 3.12)
-    # Use FindPythonInterp and FindPythonLibs for CMake <3.12
-    find_package(PythonInterp 3 REQUIRED)
-
-    set(Python3_EXECUTABLE ${PYTHON_EXECUTABLE})
-else()
-    # Use FindPython3 for CMake >=3.12
-    find_package(Python3 REQUIRED COMPONENTS Interpreter)
-endif()
-
-# Options or configuration variables
-set(CURA_NO_INSTALL_PLUGINS "" CACHE STRING "A list of plugins that should not be installed, separated with ';' or ','.")
-
-file(GLOB_RECURSE _plugin_json_list ${CMAKE_SOURCE_DIR}/plugins/*/plugin.json)
-list(LENGTH _plugin_json_list _plugin_json_list_len)
-
-# Sort the lists alphabetically so we can handle cases like this:
-#   - plugins/my_plugin/plugin.json
-#   - plugins/my_plugin/my_module/plugin.json
-# In this case, only "plugins/my_plugin" should be added via install().
-set(_no_install_plugin_list ${CURA_NO_INSTALL_PLUGINS})
-# Sanitize the string so the comparison will be case-insensitive.
-string(STRIP   "${_no_install_plugin_list}" _no_install_plugin_list)
-string(TOLOWER "${_no_install_plugin_list}" _no_install_plugin_list)
-
-# WORKAROUND counterpart of what's in cura-build.
-string(REPLACE "," ";" _no_install_plugin_list "${_no_install_plugin_list}")
-
-list(LENGTH _no_install_plugin_list _no_install_plugin_list_len)
-
-if(_no_install_plugin_list_len GREATER 0)
-    list(SORT _no_install_plugin_list)
-endif()
-if(_plugin_json_list_len GREATER 0)
-    list(SORT _plugin_json_list)
-endif()
-
-# Check all plugin directories and add them via install() if needed.
-set(_install_plugin_list "")
-foreach(_plugin_json_path ${_plugin_json_list})
-    get_filename_component(_plugin_dir ${_plugin_json_path} DIRECTORY)
-    file(RELATIVE_PATH _rel_plugin_dir ${CMAKE_CURRENT_SOURCE_DIR} ${_plugin_dir})
-    get_filename_component(_plugin_dir_name ${_plugin_dir} NAME)
-
-    # Make plugin name comparison case-insensitive
-    string(TOLOWER "${_plugin_dir_name}" _plugin_dir_name_lowercase)
-
-    # Check if this plugin needs to be skipped for installation
-    set(_add_plugin ON)  # Indicates if this plugin should be added to the build or not.
-    set(_is_no_install_plugin OFF)  # If this plugin will not be added, this indicates if it's because the plugin is
-                                    # specified in the NO_INSTALL_PLUGINS list.
-    if(_no_install_plugin_list)
-        if("${_plugin_dir_name_lowercase}" IN_LIST _no_install_plugin_list)
-            set(_add_plugin OFF)
-            set(_is_no_install_plugin ON)
-        endif()
-    endif()
-
-    # Make sure this is not a subdirectory in a plugin that's already in the install list
-    if(_add_plugin)
-        foreach(_known_install_plugin_dir ${_install_plugin_list})
-            if(_plugin_dir MATCHES "${_known_install_plugin_dir}.+")
-                set(_add_plugin OFF)
-                break()
-            endif()
-        endforeach()
-    endif()
-
-    if(_add_plugin)
-        if(${PRINT_PLUGIN_LIST})
-            message(STATUS "[+] PLUGIN TO INSTALL: ${_rel_plugin_dir}")
-        endif()
-        get_filename_component(_rel_plugin_parent_dir ${_rel_plugin_dir} DIRECTORY)
-        install(DIRECTORY ${_rel_plugin_dir}
-                DESTINATION lib${LIB_SUFFIX}/cura/${_rel_plugin_parent_dir}
-                PATTERN "__pycache__" EXCLUDE
-                PATTERN "*.qmlc" EXCLUDE
-                )
-        list(APPEND _install_plugin_list ${_plugin_dir})
-    elseif(_is_no_install_plugin)
-        if(${PRINT_PLUGIN_LIST})
-            message(STATUS "[-] PLUGIN TO REMOVE : ${_rel_plugin_dir}")
-        endif()
-        execute_process(COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/cmake/mod_bundled_packages_json.py
-                        -d ${CMAKE_CURRENT_SOURCE_DIR}/resources/bundled_packages
-                        ${_plugin_dir_name}
-                        RESULT_VARIABLE _mod_json_result)
-    endif()
-endforeach()

cmake/CuraTests.cmake

@@ -1,83 +0,0 @@
-# Copyright (c) 2018 Ultimaker B.V.
-# Cura is released under the terms of the LGPLv3 or higher.
-
-include(CTest)
-include(CMakeParseArguments)
-
-# FIXME: The new FindPython3 finds the system's Python3.6 rather than the Python3.5 that we built for Cura's environment.
-# So we're using the old method here, with FindPythonInterp for now.
-find_package(PythonInterp 3 REQUIRED)
-
-set(Python3_EXECUTABLE ${PYTHON_EXECUTABLE})
-
-add_custom_target(test-verbose COMMAND ${CMAKE_CTEST_COMMAND} --verbose)
-
-function(cura_add_test)
-    set(_single_args NAME DIRECTORY PYTHONPATH)
-    cmake_parse_arguments("" "" "${_single_args}" "" ${ARGN})
-
-    if(NOT _NAME)
-        message(FATAL_ERROR "cura_add_test requires a test name argument")
-    endif()
-
-    if(NOT _DIRECTORY)
-        message(FATAL_ERROR "cura_add_test requires a directory to test")
-    endif()
-
-    if(NOT _PYTHONPATH)
-        set(_PYTHONPATH ${_DIRECTORY})
-    endif()
-    
-    if(WIN32)
-        string(REPLACE "|" "\\;" _PYTHONPATH ${_PYTHONPATH})
-        set(_PYTHONPATH "${_PYTHONPATH}\\;$ENV{PYTHONPATH}")
-    else()
-        string(REPLACE "|" ":" _PYTHONPATH ${_PYTHONPATH})
-        set(_PYTHONPATH "${_PYTHONPATH}:$ENV{PYTHONPATH}")
-    endif()
-
-    get_test_property(${_NAME} ENVIRONMENT test_exists) #Find out if the test exists by getting a property from it that always exists (such as ENVIRONMENT because we set that ourselves).
-    if (NOT ${test_exists})
-        add_test(
-            NAME ${_NAME}
-            COMMAND ${Python3_EXECUTABLE} -m pytest --junitxml=${CMAKE_BINARY_DIR}/junit-${_NAME}.xml ${_DIRECTORY}
-        )
-        set_tests_properties(${_NAME} PROPERTIES ENVIRONMENT LANG=C)
-        set_tests_properties(${_NAME} PROPERTIES ENVIRONMENT "PYTHONPATH=${_PYTHONPATH}")
-    else()
-        message(WARNING "Duplicate test ${_NAME}!")
-    endif()
-endfunction()
-
-
-#Add code style test.
-add_test(
-    NAME "code-style"
-    COMMAND ${Python3_EXECUTABLE} run_mypy.py
-    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
-)
-
-#Add test for import statements which are not compatible with all builds
-add_test(
-    NAME "invalid-imports"
-    COMMAND ${Python3_EXECUTABLE} scripts/check_invalid_imports.py
-    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
-)
-
-cura_add_test(NAME pytest-main DIRECTORY ${CMAKE_SOURCE_DIR}/tests PYTHONPATH "${CMAKE_SOURCE_DIR}|${URANIUM_DIR}")
-
-file(GLOB_RECURSE _plugins plugins/*/__init__.py)
-foreach(_plugin ${_plugins})
-    get_filename_component(_plugin_directory ${_plugin} DIRECTORY)
-    if(EXISTS ${_plugin_directory}/tests)
-        get_filename_component(_plugin_name ${_plugin_directory} NAME)
-        cura_add_test(NAME pytest-${_plugin_name} DIRECTORY ${_plugin_directory} PYTHONPATH "${_plugin_directory}|${CMAKE_SOURCE_DIR}|${URANIUM_DIR}")
-    endif()
-endforeach()
-
-#Add test for whether the shortcut alt-keys are unique in every translation.
-add_test(
-    NAME "shortcut-keys"
-    COMMAND ${Python3_EXECUTABLE} scripts/check_shortcut_keys.py
-    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
-)

cmake/mod_bundled_packages_json.py

@@ -1,73 +0,0 @@
-#!/usr/bin/env python3
-#
-# This script removes the given package entries in the bundled_packages JSON files. This is used by the PluginInstall
-# CMake module.
-#
-
-import argparse
-import collections
-import json
-import os
-import sys
-
-
-def find_json_files(work_dir: str) -> list:
-    """Finds all JSON files in the given directory recursively and returns a list of those files in absolute paths.
-
-    :param work_dir: The directory to look for JSON files recursively.
-    :return: A list of JSON files in absolute paths that are found in the given directory.
-    """
-
-    json_file_list = []
-    for root, dir_names, file_names in os.walk(work_dir):
-        for file_name in file_names:
-            abs_path = os.path.abspath(os.path.join(root, file_name))
-            json_file_list.append(abs_path)
-    return json_file_list
-
-
-def remove_entries_from_json_file(file_path: str, entries: list) -> None:
-    """Removes the given entries from the given JSON file. The file will modified in-place.
-
-    :param file_path: The JSON file to modify.
-    :param entries: A list of strings as entries to remove.
-    :return: None
-    """
-
-    try:
-        with open(file_path, "r", encoding = "utf-8") as f:
-            package_dict = json.load(f, object_hook = collections.OrderedDict)
-    except Exception as e:
-        msg = "Failed to load '{file_path}' as a JSON file. This file will be ignored Exception: {e}"\
-            .format(file_path = file_path, e = e)
-        sys.stderr.write(msg + os.linesep)
-        return
-
-    for entry in entries:
-        if entry in package_dict:
-            del package_dict[entry]
-            print("[INFO] Remove entry [{entry}] from [{file_path}]".format(file_path = file_path, entry = entry))
-
-    try:
-        with open(file_path, "w", encoding = "utf-8", newline = "\n") as f:
-            json.dump(package_dict, f, indent = 4)
-    except Exception as e:
-        msg = "Failed to write '{file_path}' as a JSON file. Exception: {e}".format(file_path = file_path, e = e)
-        raise IOError(msg)
-
-
-def main() -> None:
-    parser = argparse.ArgumentParser("mod_bundled_packages_json")
-    parser.add_argument("-d", "--dir", dest = "work_dir",
-                        help = "The directory to look for bundled packages JSON files, recursively.")
-    parser.add_argument("entries", metavar = "ENTRIES", type = str, nargs = "+")
-
-    args = parser.parse_args()
-
-    json_file_list = find_json_files(args.work_dir)
-    for json_file_path in json_file_list:
-        remove_entries_from_json_file(json_file_path, args.entries)
-
-
-if __name__ == "__main__":
-    main()

com.ultimaker.cura.appdata.xml

@@ -1,33 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- Copyright 2016 Richard Hughes <richard@hughsie.com> -->
-<component type="desktop">
-  <id>com.ultimaker.cura.desktop</id>
-  <metadata_license>CC0-1.0</metadata_license>
-  <project_license>LGPL-3.0 and CC-BY-SA-4.0</project_license>
-  <name>Cura</name>
-  <summary>The world's most advanced 3d printer software</summary>
-  <description>
-    <p>
-      Cura creates a seamless integration between hardware, software and
-      materials for the best 3D printing experience around.
-      Cura supports the 3MF, OBJ and STL file formats and is available on
-      Windows, Mac and Linux.
-    </p>
-    <ul>
-      <li>Novices can start printing right away</li>
-      <li>Experts are able to customize 300 settings to achieve the best results</li>
-      <li>Optimized profiles for Ultimaker materials</li>
-      <li>Supported by a global network of Ultimaker certified service partners</li>
-      <li>Print multiple objects at once with different settings for each object</li>
-      <li>Cura supports STL, 3MF and OBJ file formats</li>
-      <li>Open source and completely free</li>
-    </ul>
-  </description>
-  <screenshots>
-    <screenshot type="default">
-      <image>https://raw.githubusercontent.com/Ultimaker/Cura/master/screenshot.png</image>
-    </screenshot>
-  </screenshots>
-  <url type="homepage">https://ultimaker.com/software/ultimaker-cura?utm_source=cura&amp;utm_medium=software&amp;utm_campaign=cura-update-linux</url>
-  <translation type="gettext">Cura</translation>
-</component>

com.ultimaker.cura.desktop.in

@@ -1,19 +0,0 @@
-[Desktop Entry]
-Name=Ultimaker Cura
-Name[de]=Ultimaker Cura
-Name[nl]=Ultimaker Cura
-GenericName=3D Printing Software
-GenericName[de]=3D-Druck-Software
-GenericName[nl]=3D-printsoftware
-Comment=Cura converts 3D models into paths for a 3D printer. It prepares your print for maximum accuracy, minimum printing time and good reliability with many extra features that make your print come out great.
-Comment[de]=Cura wandelt 3D-Modelle in Pfade für einen 3D-Drucker um. Es bereitet Ihren Druck für maximale Genauigkeit, minimale Druckzeit und guter Zuverlässigkeit mit vielen zusätzlichen Funktionen vor, damit Ihr Druck großartig wird.
-Comment[nl]=Cura converteert 3D-modellen naar paden voor een 3D printer. Het bereidt je print voor om zeer precies, snel en betrouwbaar te kunnen printen, met veel extra functionaliteit om je print er goed uit te laten komen.
-Exec=@CMAKE_INSTALL_FULL_BINDIR@/cura %F
-TryExec=@CMAKE_INSTALL_FULL_BINDIR@/cura
-Icon=cura-icon
-Terminal=false
-Type=Application
-MimeType=model/stl;application/vnd.ms-3mfdocument;application/prs.wavefront-obj;image/bmp;image/gif;image/jpeg;image/png;text/x-gcode;application/x-amf;application/x-ply;application/x-ctm;model/vnd.collada+xml;model/gltf-binary;model/gltf+json;model/vnd.collada+xml+zip;
-Categories=Graphics;
-Keywords=3D;Printing;Slicer;
-StartupWMClass=cura.real

conandata.yml

@@ -0,0 +1,849 @@
+---
+# 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.3.0-alpha":
+    requirements:
+        - "pyarcus/(latest)@ultimaker/testing"
+        - "curaengine/(latest)@ultimaker/testing"
+        - "pysavitar/(latest)@ultimaker/testing"
+        - "pynest2d/(latest)@ultimaker/testing"
+        - "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:
+        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"
+"5.2.1":
+    requirements:
+        - "pyarcus/5.2.0"
+        - "curaengine/5.2.1"
+        - "pysavitar/5.2.0"
+        - "pynest2d/5.2.0"
+        - "uranium/5.2.0"
+        - "fdm_materials/5.2.0"
+        - "cura_binary_data/5.2.1"
+        - "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
+            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"
+"5.2.0-beta.2":
+    requirements:
+        - "pyarcus/(latest)@ultimaker/stable"
+        - "curaengine/(latest)@ultimaker/stable"
+        - "pysavitar/(latest)@ultimaker/stable"
+        - "pynest2d/(latest)@ultimaker/stable"
+        - "uranium/(latest)@ultimaker/stable"
+        - "fdm_materials/(latest)@ultimaker/stable"
+        - "cura_binary_data/(latest)@ultimaker/stable"
+        - "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
+            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"
+"5.2.0-beta.1":
+    requirements:
+        - "pyarcus/5.2.0-beta.1"
+        - "curaengine/5.2.0-beta.1"
+        - "pysavitar/5.2.0-beta.1"
+        - "pynest2d/5.2.0-beta.1"
+        - "uranium/5.2.0-beta.1"
+        - "fdm_materials/5.2.0-beta.1"
+        - "cura_binary_data/5.2.0-beta.1"
+        - "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
+            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"
+"5.2.0":
+    requirements:
+        - "pyarcus/5.2.0"
+        - "curaengine/5.2.0"
+        - "pysavitar/5.2.0"
+        - "pynest2d/5.2.0"
+        - "uranium/5.2.0"
+        - "fdm_materials/5.2.0"
+        - "cura_binary_data/5.2.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
+            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"
+"5.2.0-alpha":
+    requirements:
+        - "pyarcus/5.2@ultimaker/testing"
+        - "curaengine/(latest)@ultimaker/testing"
+        - "pysavitar/(latest)@ultimaker/testing"
+        - "pynest2d/(latest)@ultimaker/testing"
+        - "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:
+        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
+            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"
+"5.1.0":
+    requirements:
+        - "arcus/5.1.0"
+        - "curaengine/5.1.0"
+        - "savitar/5.1.0"
+        - "pynest2d/5.1.0"
+        - "uranium/5.1.0"
+        - "fdm_materials/5.1.0"
+        - "cura_binary_data/5.1.0"
+        - "cpython/3.10.4"
+    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"
+            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"
+            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"
+pycharm_targets:
+    - jinja_path: .run_templates/pycharm_cura_run.run.xml.jinja
+      module_name: Cura
+      name: cura
+      script_name: cura_app.py
+    - jinja_path: .run_templates/pycharm_cura_run.run.xml.jinja
+      module_name: Cura
+      name: cura_external_engine
+      parameters: --external-backend
+      script_name: cura_app.py
+    - jinja_path: .run_templates/pycharm_cura_test.run.xml.jinja
+      module_name: Cura
+      name: pytest in tests
+      script_name: tests/
+    - jinja_path: .run_templates/pycharm_cura_test.run.xml.jinja
+      module_name: Cura
+      name: pytest in TestBuildVolume.py
+      script_name: tests/TestBuildVolume.py
+    - jinja_path: .run_templates/pycharm_cura_test.run.xml.jinja
+      module_name: Cura
+      name: pytest in TestConvexHullDecorator.py
+      script_name: tests/TestConvexHullDecorator.py
+    - jinja_path: .run_templates/pycharm_cura_test.run.xml.jinja
+      module_name: Cura
+      name: pytest in TestCuraSceneNode.py
+      script_name: tests/TestCuraSceneNode.py
+    - jinja_path: .run_templates/pycharm_cura_test.run.xml.jinja
+      module_name: Cura
+      name: pytest in TestCuraSceneNode.py
+      script_name: tests/TestExtruderManager.py
+    - jinja_path: .run_templates/pycharm_cura_test.run.xml.jinja
+      module_name: Cura
+      name: pytest in TestGCodeListDecorator.py
+      script_name: tests/TestGCodeListDecorator.py
+    - jinja_path: .run_templates/pycharm_cura_test.run.xml.jinja
+      module_name: Cura
+      name: pytest in TestIntentManager.py
+      script_name: tests/TestIntentManager.py
+    - jinja_path: .run_templates/pycharm_cura_test.run.xml.jinja
+      module_name: Cura
+      name: pytest in TestLayer.py
+      script_name: tests/TestLayer.py
+    - jinja_path: .run_templates/pycharm_cura_test.run.xml.jinja
+      module_name: Cura
+      name: pytest in TestMachineAction.py
+      script_name: tests/TestMachineAction.py
+    - jinja_path: .run_templates/pycharm_cura_test.run.xml.jinja
+      module_name: Cura
+      name: pytest in TestMachineManager.py
+      script_name: tests/TestMachineManager.py
+    - jinja_path: .run_templates/pycharm_cura_test.run.xml.jinja
+      module_name: Cura
+      name: pytest in TestOAuth2.py
+      script_name: tests/TestOAuth2.py
+    - jinja_path: .run_templates/pycharm_cura_test.run.xml.jinja
+      module_name: Cura
+      name: pytest in TestObjectsModel.py
+      script_name: tests/TestObjectsModel.py
+    - jinja_path: .run_templates/pycharm_cura_test.run.xml.jinja
+      module_name: Cura
+      name: pytest in TestPrintInformation.py
+      script_name: tests/TestPrintInformation.py
+    - jinja_path: .run_templates/pycharm_cura_test.run.xml.jinja
+      module_name: Cura
+      name: pytest in TestProfileRequirements.py
+      script_name: tests/TestProfileRequirements.py
+    - jinja_path: .run_templates/pycharm_cura_test.run.xml.jinja
+      module_name: Cura
+      name: pytest in TestThemes.py
+      script_name: tests/TestThemes.py
+    - jinja_path: .run_templates/pycharm_cura_test.run.xml.jinja
+      module_name: Cura
+      name: pytest in TestContainerManager.py
+      script_name: tests/Settings/TestContainerManager.py
+    - jinja_path: .run_templates/pycharm_cura_test.run.xml.jinja
+      module_name: Cura
+      name: pytest in TestCuraContainerRegistry.py
+      script_name: tests/Settings/TestCuraContainerRegistry.py
+    - jinja_path: .run_templates/pycharm_cura_test.run.xml.jinja
+      module_name: Cura
+      name: pytest in TestCuraStackBuilder.py
+      script_name: tests/Settings/TestCuraStackBuilder.py
+    - jinja_path: .run_templates/pycharm_cura_test.run.xml.jinja
+      module_name: Cura
+      name: pytest in TestDefinitionContainer.py
+      script_name: tests/Settings/TestDefinitionContainer.py
+    - jinja_path: .run_templates/pycharm_cura_test.run.xml.jinja
+      module_name: Cura
+      name: pytest in TestExtruderStack.py
+      script_name: tests/Settings/TestExtruderStack.py
+    - jinja_path: .run_templates/pycharm_cura_test.run.xml.jinja
+      module_name: Cura
+      name: pytest in TestGlobalStack.py
+      script_name: tests/Settings/TestGlobalStack.py
+    - jinja_path: .run_templates/pycharm_cura_test.run.xml.jinja
+      module_name: Cura
+      name: pytest in TestProfiles.py
+      script_name: tests/Settings/TestProfiles.py
+    - jinja_path: .run_templates/pycharm_cura_test.run.xml.jinja
+      module_name: Cura
+      name: pytest in TestSettingInheritanceManager.py
+      script_name: tests/Settings/TestSettingInheritanceManager.py
+    - jinja_path: .run_templates/pycharm_cura_test.run.xml.jinja
+      module_name: Cura
+      name: pytest in TestSettingOverrideDecorator.py
+      script_name: tests/Settings/TestSettingOverrideDecorator.py
+    - jinja_path: .run_templates/pycharm_cura_test.run.xml.jinja
+      module_name: Cura
+      name: pytest in TestSettingVisibilityPresets.py
+      script_name: tests/Settings/TestSettingVisibilityPresets.py

conanfile.py

@@ -0,0 +1,484 @@
+import os
+from pathlib import Path
+
+from jinja2 import Template
+
+from conan import ConanFile
+from conan.tools.files import copy, rmdir, save, mkdir
+from conan.tools.microsoft import unix_path
+from conan.tools.env import VirtualRunEnv, Environment
+from conan.tools.scm import Version
+from conan.errors import ConanInvalidConfiguration, ConanException
+
+required_conan_version = ">=1.52.0"
+
+
+class CuraConan(ConanFile):
+    name = "cura"
+    license = "LGPL-3.0"
+    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")
+    build_policy = "missing"
+    exports = "LICENSE*", "UltiMaker-Cura.spec.jinja", "CuraVersion.py.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"
+    python_requires_extend = "umbase.UMBaseConanfile"
+
+    options = {
+        "enterprise": ["True", "False", "true", "false"],  # Workaround for GH Action passing boolean as lowercase string
+        "staging": ["True", "False", "true", "false"],  # Workaround for GH Action passing boolean as lowercase string
+        "devtools": [True, False],  # FIXME: Split this up in testing and (development / build (pyinstaller) / system installer) tools
+        "cloud_api_version": "ANY",
+        "display_name": "ANY",  # TODO: should this be an option??
+        "cura_debug_mode": [True, False],  # FIXME: Use profiles
+        "internal": [True, False]
+    }
+    default_options = {
+        "enterprise": "False",
+        "staging": "False",
+        "devtools": False,
+        "cloud_api_version": "1",
+        "display_name": "UltiMaker Cura",
+        "cura_debug_mode": False,  # Not yet implemented
+        "internal": False,
+    }
+    scm = {
+        "type": "git",
+        "subfolder": ".",
+        "url": "auto",
+        "revision": "auto"
+    }
+
+    @property
+    def _pycharm_targets(self):
+        return self.conan_data["pycharm_targets"]
+
+    # FIXME: These env vars should be defined in the runenv.
+    _cura_env = None
+
+    @property
+    def _cura_run_env(self):
+        if self._cura_env:
+            return self._cura_env
+
+        self._cura_env = Environment()
+        self._cura_env.define("QML2_IMPORT_PATH", str(self._site_packages.joinpath("PyQt6", "Qt6", "qml")))
+        self._cura_env.define("QT_PLUGIN_PATH", str(self._site_packages.joinpath("PyQt6", "Qt6", "plugins")))
+
+        if self.settings.os == "Linux":
+            self._cura_env.define("QT_QPA_FONTDIR", "/usr/share/fonts")
+            self._cura_env.define("QT_QPA_PLATFORMTHEME", "xdgdesktopportal")
+            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']
+
+    @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"
+
+    @property
+    def requirements_txts(self):
+        if self.options.devtools:
+            return ["requirements.txt", "requirements-ultimaker.txt", "requirements-dev.txt"]
+        return ["requirements.txt", "requirements-ultimaker.txt"]
+
+    @property
+    def _base_dir(self):
+        if self.install_folder is None:
+            if self.build_folder is not None:
+                return Path(self.build_folder)
+            return Path(os.getcwd(), "venv")
+        if self.in_local_cache:
+            return Path(self.install_folder)
+        else:
+            return Path(self.source_folder, "venv")
+
+    @property
+    def _share_dir(self):
+        return self._base_dir.joinpath("share")
+
+    @property
+    def _script_dir(self):
+        if self.settings.os == "Windows":
+            return self._base_dir.joinpath("Scripts")
+        return self._base_dir.joinpath("bin")
+
+    @property
+    def _site_packages(self):
+        if self.settings.os == "Windows":
+            return self._base_dir.joinpath("Lib", "site-packages")
+        py_version = Version(self.deps_cpp_info["cpython"].version)
+        return self._base_dir.joinpath("lib", f"python{py_version.major}.{py_version.minor}", "site-packages")
+
+    @property
+    def _py_interp(self):
+        py_interp = self._script_dir.joinpath(Path(self.deps_user_info["cpython"].python).name)
+        if self.settings.os == "Windows":
+            py_interp = Path(*[f'"{p}"' if " " in p else p for p in py_interp.parts])
+        return py_interp
+
+    def _generate_cura_version(self, location):
+        with open(Path(__file__).parent.joinpath("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`
+        # the global.conf, profile, package_info (of dependency) or via the cmd line `-c user.cura:version=VERSION`
+        cura_version = Version(self.conf.get("user.cura:version", default = self.version, check_type = str))
+        pre_tag = f"-{cura_version.pre}" if cura_version.pre else ""
+        build_tag = f"+{cura_version.build}" if cura_version.build else ""
+        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:
+            f.write(cura_version_py.render(
+                cura_app_name = self.name,
+                cura_app_display_name = self.options.display_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_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))
+
+    def _generate_pyinstaller_spec(self, location, entrypoint_location, icon_path, entitlements_file):
+        pyinstaller_metadata = self._um_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):
+                continue
+
+            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"])
+                    else:
+                        src_path = Path(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"])
+            else:
+                continue
+            if 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"])
+            elif "root" in binary:  # get the paths relative from the sourcefolder
+                src_path = Path(self.source_folder, binary["root"], binary["src"])
+            else:
+                continue
+            if not 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.]*"):
+                binaries.append((str(bin), binary["dst"]))
+            for bin in 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
+        for _, dependency in self.dependencies.host.items():
+            for bin_paths in dependency.cpp_info.bindirs:
+                binaries.extend([(f"{p}", ".") for p in Path(bin_paths).glob("**/*.dll")])
+            for lib_paths in dependency.cpp_info.libdirs:
+                binaries.extend([(f"{p}", ".") for p in Path(lib_paths).glob("**/*.so*")])
+                binaries.extend([(f"{p}", ".") for p in Path(lib_paths).glob("**/*.dylib*")])
+
+        # Copy dynamic libs from lib path
+        binaries.extend([(f"{p}", ".") for p in Path(self._base_dir.joinpath("lib")).glob("**/*.dylib*")])
+        binaries.extend([(f"{p}", ".") for p in Path(self._base_dir.joinpath("lib")).glob("**/*.so*")])
+
+        # 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:
+            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:
+            f.write(pyinstaller.render(
+                name = str(self.options.display_name).replace(" ", "-"),
+                display_name = self.options.display_name,
+                entrypoint = entrypoint_location,
+                datas = datas,
+                binaries = binaries,
+                venv_script_path = str(self._script_dir),
+                hiddenimports = pyinstaller_metadata["hiddenimports"],
+                collect_all = pyinstaller_metadata["collect_all"],
+                icon = icon_path,
+                entitlements_file = entitlements_file,
+                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
+                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 configure(self):
+        self.options["pyarcus"].shared = True
+        self.options["pysavitar"].shared = True
+        self.options["pynest2d"].shared = True
+        self.options["cpython"].shared = True
+
+    def validate(self):
+        version = self.conf_info.get("user.cura:version", default = self.version, check_type = str)
+        if version and Version(version) <= Version("4"):
+            raise ConanInvalidConfiguration("Only versions 5+ are support")
+
+    def requirements(self):
+        for req in self._um_data()["requirements"]:
+            self.requires(req)
+        if self.options.internal:
+            for req in self._um_data()["internal_requirements"]:
+                self.requires(req)
+
+    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)
+
+    def layout(self):
+        self.folders.source = "."
+        self.folders.build = "venv"
+        self.folders.generators = Path(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):
+        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}"))
+
+        vr = VirtualRunEnv(self)
+        vr.generate()
+
+        self._generate_cura_version(Path(self.source_folder, "cura"))
+
+        if self.options.devtools:
+            entitlements_file = "'{}'".format(Path(self.source_folder, "packaging", "dmg", "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")
+
+            # 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
+                cpp_info = self.dependencies["gettext"].cpp_info
+                for po_file in self.source_path.joinpath("resources", "i18n").glob("**/*.po"):
+                    pot_file = self.source_path.joinpath("resources", "i18n", po_file.with_suffix('.pot').name)
+                    mkdir(self, str(unix_path(self, pot_file.parent)))
+                    self.run(f"{cpp_info.bindirs[0]}/msgmerge --no-wrap --no-fuzzy-matching -width=140 -o {po_file} {po_file} {pot_file}",
+                             env = "conanbuild", ignore_errors = True)
+
+    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 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)
+
+        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)
+
+        # 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)
+
+        # 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)
+
+        # 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"))
+
+        # Generate the GitHub Action version info Environment
+        version = self.conf_info.get("user.cura:version", default = self.version, check_type = str)
+        cura_version = Version(version)
+        env_prefix = "Env:" if self.settings.os == "Windows" else ""
+        activate_github_actions_version_env = Template(r"""echo "CURA_VERSION_MAJOR={{ cura_version_major }}" >> ${{ env_prefix }}GITHUB_ENV
+echo "CURA_VERSION_MINOR={{ cura_version_minor }}" >> ${{ env_prefix }}GITHUB_ENV
+echo "CURA_VERSION_PATCH={{ cura_version_patch }}" >> ${{ env_prefix }}GITHUB_ENV
+echo "CURA_VERSION_BUILD={{ cura_version_build }}" >> ${{ env_prefix }}GITHUB_ENV
+echo "CURA_VERSION_FULL={{ cura_version_full }}" >> ${{ env_prefix }}GITHUB_ENV
+        """).render(cura_version_major = cura_version.major,
+                    cura_version_minor = cura_version.minor,
+                    cura_version_patch = cura_version.patch,
+                    cura_version_build = cura_version.build if cura_version.build != "" else "0",
+                    cura_version_full = self.version,
+                    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)
+
+        self._generate_cura_version(Path(self._site_packages, "cura"))
+
+        entitlements_file = "'{}'".format(Path(self.cpp_info.res_paths[2], "dmg", "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("\\", "\\\\"),
+                                        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]))
+
+    def package_info(self):
+        self.user_info.pip_requirements = "requirements.txt"
+        self.user_info.pip_requirements_git = "requirements-ultimaker.txt"
+        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
+        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
+
+        # 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@_/_`
+        del self.info.options.enterprise
+        del self.info.options.staging
+        del self.info.options.devtools
+        del self.info.options.cloud_api_version
+        del self.info.options.display_name
+        del self.info.options.cura_debug_mode
+
+        # TODO: Use the hash of requirements.txt and requirements-ultimaker.txt, Because changing these will actually result in a different
+        #  Cura. This is needed because the requirements.txt aren't managed by Conan and therefor not resolved in the package_id. This isn't
+        #  ideal but an acceptable solution for now.

contributing.md

@@ -16,4 +16,6 @@ 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.
 
-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`.
+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`.

cura/API/Account.py

@@ -1,24 +1,31 @@
-# Copyright (c) 2021 Ultimaker B.V.
+# Copyright (c) 2022 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
-
+import enum
 from datetime import datetime
-from PyQt5.QtCore import QObject, pyqtSignal, pyqtSlot, pyqtProperty, QTimer, Q_ENUMS
-from typing import Any, Optional, Dict, TYPE_CHECKING, Callable
+import json
+from PyQt6.QtCore import QObject, pyqtSignal, pyqtSlot, pyqtProperty, QTimer, pyqtEnum
+from PyQt6.QtNetwork import QNetworkRequest
+from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING
 
+from UM.Decorators import deprecated
 from UM.Logger import Logger
 from UM.Message import Message
 from UM.i18n import i18nCatalog
+from UM.TaskManagement.HttpRequestManager import HttpRequestManager
+from UM.TaskManagement.HttpRequestScope import JsonDecoratorScope
 from cura.OAuth2.AuthorizationService import AuthorizationService
 from cura.OAuth2.Models import OAuth2Settings, UserProfile
 from cura.UltimakerCloud import UltimakerCloudConstants
+from cura.UltimakerCloud.UltimakerCloudScope import UltimakerCloudScope
 
 if TYPE_CHECKING:
     from cura.CuraApplication import CuraApplication
+    from PyQt6.QtNetwork import QNetworkReply
 
 i18n_catalog = i18nCatalog("cura")
 
 
-class SyncState:
+class SyncState(enum.IntEnum):
     """QML: Cura.AccountSyncState"""
     SYNCING = 0
     SUCCESS = 1
@@ -41,7 +48,7 @@ class Account(QObject):
 
     # The interval in which sync services are automatically triggered
     SYNC_INTERVAL = 60.0  # seconds
-    Q_ENUMS(SyncState)
+    pyqtEnum(SyncState)
 
     loginStateChanged = pyqtSignal(bool)
     """Signal emitted when user logged in or out"""
@@ -78,6 +85,7 @@ class Account(QObject):
         self._logged_in = False
         self._user_profile: Optional[UserProfile] = None
         self._additional_rights: Dict[str, Any] = {}
+        self._permissions: List[str] = []  # List of account permission keys, e.g. ["digital-factory.print-job.write"]
         self._sync_state = SyncState.IDLE
         self._manual_sync_enabled = False
         self._update_packages_enabled = False
@@ -109,6 +117,7 @@ class Account(QObject):
 
         self._sync_services: Dict[str, int] = {}
         """contains entries "service_name" : SyncState"""
+        self.syncRequested.connect(self._updatePermissions)
 
     def initialize(self) -> None:
         self._authorization_service.initialize(self._application.getPreferences())
@@ -269,10 +278,10 @@ class Account(QObject):
         return self._authorization_service.getAccessToken()
 
     @pyqtProperty("QVariantMap", notify = userProfileChanged)
-    def userProfile(self) -> Optional[Dict[str, Optional[str]]]:
+    def userProfile(self) -> Dict[str, Optional[str]]:
         """None if no user is logged in otherwise the logged in  user as a dict containing containing user_id, username and profile_image_url """
         if not self._user_profile:
-            return None
+            return {}
         return self._user_profile.__dict__
 
     @pyqtProperty(str, notify=lastSyncDateTimeChanged)
@@ -311,13 +320,63 @@ class Account(QObject):
 
         self._authorization_service.deleteAuthData()
 
+    @deprecated("Get permissions from the 'permissions' property", since = "5.2.0")
     def updateAdditionalRight(self, **kwargs) -> None:
         """Update the additional rights of the account.
         The argument(s) are the rights that need to be set"""
         self._additional_rights.update(kwargs)
         self.additionalRightsChanged.emit(self._additional_rights)
 
+    @deprecated("Get permissions from the 'permissions' property", since = "5.2.0")
     @pyqtProperty("QVariantMap", notify = additionalRightsChanged)
     def additionalRights(self) -> Dict[str, Any]:
         """A dictionary which can be queried for additional account rights."""
         return self._additional_rights
+
+    permissionsChanged = pyqtSignal()
+    @pyqtProperty("QVariantList", notify = permissionsChanged)
+    def permissions(self) -> List[str]:
+        """
+        The permission keys that the user has in his account.
+        """
+        return self._permissions
+
+    def _updatePermissions(self) -> None:
+        """
+        Update the list of permissions that the user has.
+        """
+        def callback(reply: "QNetworkReply"):
+            status_code = reply.attribute(QNetworkRequest.Attribute.HttpStatusCodeAttribute)
+            if status_code is None:
+                Logger.error("Server did not respond to request to get list of permissions.")
+                return
+            if status_code >= 300:
+                Logger.error(f"Request to get list of permission resulted in HTTP error {status_code}")
+                return
+
+            try:
+                reply_data = json.loads(bytes(reply.readAll()).decode("UTF-8"))
+            except (UnicodeDecodeError, json.JSONDecodeError, ValueError) as e:
+                Logger.logException("e", f"Could not parse response to permission list request: {e}")
+                return
+            if "errors" in reply_data:
+                Logger.error(f"Request to get list of permission resulted in error response: {reply_data['errors']}")
+                return
+
+            if "data" in reply_data and "permissions" in reply_data["data"]:
+                permissions = sorted(reply_data["data"]["permissions"])
+                if permissions != self._permissions:
+                    self._permissions = permissions
+                    self.permissionsChanged.emit()
+
+        def error_callback(reply: "QNetworkReply", error: "QNetworkReply.NetworkError"):
+            Logger.error(f"Request for user permissions list failed. Network error: {error}")
+
+        HttpRequestManager.getInstance().get(
+            url = f"{self._oauth_root}/users/permissions",
+            scope = JsonDecoratorScope(UltimakerCloudScope(self._application)),
+            callback = callback,
+            error_callback = error_callback,
+            timeout = 10
+        )
+

cura/API/ConnectionStatus.py

@@ -1,6 +1,6 @@
 from typing import Optional
 
-from PyQt5.QtCore import QObject, pyqtSignal, pyqtProperty
+from PyQt6.QtCore import QObject, pyqtSignal, pyqtProperty
 
 from UM.TaskManagement.HttpRequestManager import HttpRequestManager
 

cura/API/__init__.py

@@ -2,7 +2,7 @@
 # Cura is released under the terms of the LGPLv3 or higher.
 from typing import Optional, TYPE_CHECKING
 
-from PyQt5.QtCore import QObject, pyqtProperty
+from PyQt6.QtCore import QObject, pyqtProperty
 
 from cura.API.Backups import Backups
 from cura.API.ConnectionStatus import ConnectionStatus
@@ -34,12 +34,13 @@ class CuraAPI(QObject):
             raise RuntimeError("Tried to create singleton '{class_name}' more than once.".format(class_name = CuraAPI.__name__))
         if application is None:
             raise RuntimeError("Upon first time creation, the application must be set.")
-        cls.__instance = super(CuraAPI, cls).__new__(cls)
+        instance = super(CuraAPI, cls).__new__(cls)
         cls._application = application
-        return cls.__instance
+        return instance
 
     def __init__(self, application: Optional["CuraApplication"] = None) -> None:
         super().__init__(parent = CuraAPI._application)
+        CuraAPI.__instance = self
 
         self._account = Account(self._application)
 

cura/ApplicationMetadata.py

@@ -1,19 +1,27 @@
-# Copyright (c) 2021 Ultimaker B.V.
-# Cura is released under the terms of the LGPLv3 or higher.
+#  Copyright (c) 2022 UltiMaker
+#  Cura is released under the terms of the LGPLv3 or higher.
 
 # ---------
 # General constants used in Cura
 # ---------
 DEFAULT_CURA_APP_NAME = "cura"
-DEFAULT_CURA_DISPLAY_NAME = "Ultimaker Cura"
-DEFAULT_CURA_VERSION = "master"
+DEFAULT_CURA_DISPLAY_NAME = "UltiMaker Cura"
+DEFAULT_CURA_VERSION = "dev"
 DEFAULT_CURA_BUILD_TYPE = ""
 DEFAULT_CURA_DEBUG_MODE = False
+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 = "7.9.0"
+CuraSDKVersion = "8.2.0"
+
+try:
+    from cura.CuraVersion import CuraLatestURL
+    if CuraLatestURL == "":
+        CuraLatestURL = DEFAULT_CURA_LATEST_URL
+except ImportError:
+    CuraLatestURL = DEFAULT_CURA_LATEST_URL
 
 try:
     from cura.CuraVersion import CuraAppName  # type: ignore
@@ -60,3 +68,14 @@ try:
 
 except ImportError:
     CuraAppDisplayName = DEFAULT_CURA_DISPLAY_NAME
+
+DEPENDENCY_INFO = {}
+try:
+    from pathlib import Path
+    conan_install_info = Path(__file__).parent.parent.joinpath("conan_install_info.json")
+    if conan_install_info.exists():
+        import json
+        with open(conan_install_info, "r") as f:
+            DEPENDENCY_INFO = json.loads(f.read())
+except:
+    pass

cura/Arranging/Arrange.py

@@ -1,258 +0,0 @@
-# Copyright (c) 2020 Ultimaker B.V.
-# Cura is released under the terms of the LGPLv3 or higher.
-from typing import Optional
-
-from UM.Decorators import deprecated
-from UM.Scene.Iterator.DepthFirstIterator import DepthFirstIterator
-from UM.Logger import Logger
-from UM.Math.Polygon import Polygon
-from UM.Math.Vector import Vector
-from UM.Scene.SceneNode import SceneNode
-from cura.Arranging.ShapeArray import ShapeArray
-from cura.BuildVolume import BuildVolume
-from cura.Scene import ZOffsetDecorator
-
-from collections import namedtuple
-
-import numpy
-import copy
-
-LocationSuggestion = namedtuple("LocationSuggestion", ["x", "y", "penalty_points", "priority"])
-"""Return object for  bestSpot"""
-
-
-class Arrange:
-    """
-    The Arrange classed is used together with :py:class:`cura.Arranging.ShapeArray.ShapeArray`. Use it to find good locations for objects that you try to put
-    on a build place. Different priority schemes can be defined so it alters the behavior while using the same logic.
-
-    .. note::
-
-       Make sure the scale is the same between :py:class:`cura.Arranging.ShapeArray.ShapeArray` objects and the :py:class:`cura.Arranging.Arrange.Arrange` instance.
-    """
-
-    build_volume = None  # type: Optional[BuildVolume]
-
-    @deprecated("Use the functions in Nest2dArrange instead", "4.8")
-    def __init__(self, x, y, offset_x, offset_y, scale = 0.5):
-        self._scale = scale  # convert input coordinates to arrange coordinates
-        world_x, world_y = int(x * self._scale), int(y * self._scale)
-        self._shape = (world_y, world_x)
-        self._priority = numpy.zeros((world_y, world_x), dtype=numpy.int32)  # beware: these are indexed (y, x)
-        self._priority_unique_values = []
-        self._occupied = numpy.zeros((world_y, world_x), dtype=numpy.int32)  # beware: these are indexed (y, x)
-        self._offset_x = int(offset_x * self._scale)
-        self._offset_y = int(offset_y * self._scale)
-        self._last_priority = 0
-        self._is_empty = True
-
-    @classmethod
-    @deprecated("Use the functions in Nest2dArrange instead", "4.8")
-    def create(cls, scene_root = None, fixed_nodes = None, scale = 0.5, x = 350, y = 250, min_offset = 8) -> "Arrange":
-        """Helper to create an :py:class:`cura.Arranging.Arrange.Arrange` instance
-
-        Either fill in scene_root and create will find all sliceable nodes by itself, or use fixed_nodes to provide the
-        nodes yourself.
-
-        :param scene_root: Root for finding all scene nodes default = None
-        :param fixed_nodes: Scene nodes to be placed default = None
-        :param scale: default = 0.5
-        :param x: default = 350
-        :param y: default = 250
-        :param min_offset: default = 8
-        """
-
-        arranger = Arrange(x, y, x // 2, y // 2, scale = scale)
-        arranger.centerFirst()
-
-        if fixed_nodes is None:
-            fixed_nodes = []
-            for node_ in DepthFirstIterator(scene_root):
-                # Only count sliceable objects
-                if node_.callDecoration("isSliceable"):
-                    fixed_nodes.append(node_)
-
-        # Place all objects fixed nodes
-        for fixed_node in fixed_nodes:
-            vertices = fixed_node.callDecoration("getConvexHullHead") or fixed_node.callDecoration("getConvexHull")
-            if not vertices:
-                continue
-            vertices = vertices.getMinkowskiHull(Polygon.approximatedCircle(min_offset))
-            points = copy.deepcopy(vertices._points)
-
-            # After scaling (like up to 0.1 mm) the node might not have points
-            if not points.size:
-                continue
-            try:
-                shape_arr = ShapeArray.fromPolygon(points, scale = scale)
-            except ValueError:
-                Logger.logException("w", "Unable to create polygon")
-                continue
-            arranger.place(0, 0, shape_arr)
-
-        # If a build volume was set, add the disallowed areas
-        if Arrange.build_volume:
-            disallowed_areas = Arrange.build_volume.getDisallowedAreasNoBrim()
-            for area in disallowed_areas:
-                points = copy.deepcopy(area._points)
-                shape_arr = ShapeArray.fromPolygon(points, scale = scale)
-                arranger.place(0, 0, shape_arr, update_empty = False)
-        return arranger
-
-    def resetLastPriority(self):
-        """This resets the optimization for finding location based on size"""
-
-        self._last_priority = 0
-
-    @deprecated("Use the functions in Nest2dArrange instead", "4.8")
-    def findNodePlacement(self, node: SceneNode, offset_shape_arr: ShapeArray, hull_shape_arr: ShapeArray, step = 1) -> bool:
-        """Find placement for a node (using offset shape) and place it (using hull shape)
-
-        :param node: The node to be placed
-        :param offset_shape_arr: shape array with offset, for placing the shape
-        :param hull_shape_arr: shape array without offset, used to find location
-        :param step: default = 1
-        :return: the nodes that should be placed
-        """
-
-        best_spot = self.bestSpot(
-            hull_shape_arr, start_prio = self._last_priority, step = step)
-        x, y = best_spot.x, best_spot.y
-
-        # Save the last priority.
-        self._last_priority = best_spot.priority
-
-        # Ensure that the object is above the build platform
-        node.removeDecorator(ZOffsetDecorator.ZOffsetDecorator)
-        bbox = node.getBoundingBox()
-        if bbox:
-            center_y = node.getWorldPosition().y - bbox.bottom
-        else:
-            center_y = 0
-
-        if x is not None:  # We could find a place
-            node.setPosition(Vector(x, center_y, y))
-            found_spot = True
-            self.place(x, y, offset_shape_arr)  # place the object in arranger
-        else:
-            Logger.log("d", "Could not find spot!")
-            found_spot = False
-            node.setPosition(Vector(200, center_y, 100))
-        return found_spot
-
-    def centerFirst(self):
-        """Fill priority, center is best. Lower value is better. """
-
-        # Square distance: creates a more round shape
-        self._priority = numpy.fromfunction(
-            lambda j, i: (self._offset_x - i) ** 2 + (self._offset_y - j) ** 2, self._shape, dtype=numpy.int32)
-        self._priority_unique_values = numpy.unique(self._priority)
-        self._priority_unique_values.sort()
-
-    def backFirst(self):
-        """Fill priority, back is best. Lower value is better """
-
-        self._priority = numpy.fromfunction(
-            lambda j, i: 10 * j + abs(self._offset_x - i), self._shape, dtype=numpy.int32)
-        self._priority_unique_values = numpy.unique(self._priority)
-        self._priority_unique_values.sort()
-
-    def checkShape(self, x, y, shape_arr) -> Optional[numpy.ndarray]:
-        """Return the amount of "penalty points" for polygon, which is the sum of priority
-
-        :param x: x-coordinate to check shape
-        :param y: y-coordinate to check shape
-        :param shape_arr: the shape array object to place
-        :return: None if occupied
-        """
-
-        x = int(self._scale * x)
-        y = int(self._scale * y)
-        offset_x = x + self._offset_x + shape_arr.offset_x
-        offset_y = y + self._offset_y + shape_arr.offset_y
-        if offset_x < 0 or offset_y < 0:
-            return None  # out of bounds in self._occupied
-        occupied_x_max = offset_x + shape_arr.arr.shape[1]
-        occupied_y_max = offset_y + shape_arr.arr.shape[0]
-        if occupied_x_max > self._occupied.shape[1] + 1 or occupied_y_max > self._occupied.shape[0] + 1:
-            return None  # out of bounds in self._occupied
-        occupied_slice = self._occupied[
-            offset_y:occupied_y_max,
-            offset_x:occupied_x_max]
-        try:
-            if numpy.any(occupied_slice[numpy.where(shape_arr.arr == 1)]):
-                return None
-        except IndexError:  # out of bounds if you try to place an object outside
-            return None
-        prio_slice = self._priority[
-            offset_y:offset_y + shape_arr.arr.shape[0],
-            offset_x:offset_x + shape_arr.arr.shape[1]]
-        return numpy.sum(prio_slice[numpy.where(shape_arr.arr == 1)])
-
-    def bestSpot(self, shape_arr, start_prio = 0, step = 1) -> LocationSuggestion:
-        """Find "best" spot for ShapeArray
-
-        :param shape_arr: shape array
-        :param start_prio: Start with this priority value (and skip the ones before)
-        :param step: Slicing value, higher = more skips = faster but less accurate
-        :return: namedtuple with properties x, y, penalty_points, priority.
-        """
-
-        start_idx_list = numpy.where(self._priority_unique_values == start_prio)
-        if start_idx_list:
-            try:
-                start_idx = start_idx_list[0][0]
-            except IndexError:
-                start_idx = 0
-        else:
-            start_idx = 0
-        priority = 0
-        for priority in self._priority_unique_values[start_idx::step]:
-            tryout_idx = numpy.where(self._priority == priority)
-            for idx in range(len(tryout_idx[0])):
-                x = tryout_idx[1][idx]
-                y = tryout_idx[0][idx]
-                projected_x = int((x - self._offset_x) / self._scale)
-                projected_y = int((y - self._offset_y) / self._scale)
-
-                penalty_points = self.checkShape(projected_x, projected_y, shape_arr)
-                if penalty_points is not None:
-                    return LocationSuggestion(x = projected_x, y = projected_y, penalty_points = penalty_points, priority = priority)
-        return LocationSuggestion(x = None, y = None, penalty_points = None, priority = priority)  # No suitable location found :-(
-
-    def place(self, x, y, shape_arr, update_empty = True):
-        """Place the object.
-
-        Marks the locations in self._occupied and self._priority
-
-        :param x:
-        :param y:
-        :param shape_arr:
-        :param update_empty: updates the _is_empty, used when adding disallowed areas
-        """
-
-        x = int(self._scale * x)
-        y = int(self._scale * y)
-        offset_x = x + self._offset_x + shape_arr.offset_x
-        offset_y = y + self._offset_y + shape_arr.offset_y
-        shape_y, shape_x = self._occupied.shape
-
-        min_x = min(max(offset_x, 0), shape_x - 1)
-        min_y = min(max(offset_y, 0), shape_y - 1)
-        max_x = min(max(offset_x + shape_arr.arr.shape[1], 0), shape_x - 1)
-        max_y = min(max(offset_y + shape_arr.arr.shape[0], 0), shape_y - 1)
-        occupied_slice = self._occupied[min_y:max_y, min_x:max_x]
-        # we use a slice of shape because it can be out of bounds
-        new_occupied = numpy.where(shape_arr.arr[
-            min_y - offset_y:max_y - offset_y, min_x - offset_x:max_x - offset_x] == 1)
-        if update_empty and new_occupied:
-            self._is_empty = False
-        occupied_slice[new_occupied] = 1
-
-        # Set priority to low (= high number), so it won't get picked at trying out.
-        prio_slice = self._priority[min_y:max_y, min_x:max_x]
-        prio_slice[new_occupied] = 999
-
-    @property
-    def isEmpty(self):
-        return self._is_empty

cura/Arranging/ArrangeObjectsAllBuildPlatesJob.py

@@ -1,154 +0,0 @@
-# Copyright (c) 2019 Ultimaker B.V.
-# Cura is released under the terms of the LGPLv3 or higher.
-
-from UM.Application import Application
-from UM.Job import Job
-from UM.Scene.SceneNode import SceneNode
-from UM.Math.Vector import Vector
-from UM.Operations.TranslateOperation import TranslateOperation
-from UM.Operations.GroupedOperation import GroupedOperation
-from UM.Message import Message
-from UM.i18n import i18nCatalog
-i18n_catalog = i18nCatalog("cura")
-
-from cura.Scene.ZOffsetDecorator import ZOffsetDecorator
-from cura.Arranging.Arrange import Arrange
-from cura.Arranging.ShapeArray import ShapeArray
-
-from typing import List
-
-
-class ArrangeArray:
-    """Do arrangements on multiple build plates (aka builtiplexer)"""
-
-    def __init__(self, x: int, y: int, fixed_nodes: List[SceneNode]) -> None:
-        self._x = x
-        self._y = y
-        self._fixed_nodes = fixed_nodes
-        self._count = 0
-        self._first_empty = None
-        self._has_empty = False
-        self._arrange = []  # type: List[Arrange]
-
-    def _updateFirstEmpty(self):
-        for i, a in enumerate(self._arrange):
-            if a.isEmpty:
-                self._first_empty = i
-                self._has_empty = True
-                return
-        self._first_empty = None
-        self._has_empty = False
-
-    def add(self):
-        new_arrange = Arrange.create(x = self._x, y = self._y, fixed_nodes = self._fixed_nodes)
-        self._arrange.append(new_arrange)
-        self._count += 1
-        self._updateFirstEmpty()
-
-    def count(self):
-        return self._count
-
-    def get(self, index):
-        return self._arrange[index]
-
-    def getFirstEmpty(self):
-        if not self._has_empty:
-            self.add()
-        return self._arrange[self._first_empty]
-
-
-class ArrangeObjectsAllBuildPlatesJob(Job):
-    def __init__(self, nodes: List[SceneNode], min_offset = 8) -> None:
-        super().__init__()
-        self._nodes = nodes
-        self._min_offset = min_offset
-
-    def run(self):
-        status_message = Message(i18n_catalog.i18nc("@info:status", "Finding new location for objects"),
-                                 lifetime = 0,
-                                 dismissable=False,
-                                 progress = 0,
-                                 title = i18n_catalog.i18nc("@info:title", "Finding Location"))
-        status_message.show()
-
-
-        # Collect nodes to be placed
-        nodes_arr = []  # fill with (size, node, offset_shape_arr, hull_shape_arr)
-        for node in self._nodes:
-            offset_shape_arr, hull_shape_arr = ShapeArray.fromNode(node, min_offset = self._min_offset)
-            nodes_arr.append((offset_shape_arr.arr.shape[0] * offset_shape_arr.arr.shape[1], node, offset_shape_arr, hull_shape_arr))
-
-        # Sort the nodes with the biggest area first.
-        nodes_arr.sort(key=lambda item: item[0])
-        nodes_arr.reverse()
-
-        global_container_stack = Application.getInstance().getGlobalContainerStack()
-        machine_width = global_container_stack.getProperty("machine_width", "value")
-        machine_depth = global_container_stack.getProperty("machine_depth", "value")
-
-        x, y = machine_width, machine_depth
-
-        arrange_array = ArrangeArray(x = x, y = y, fixed_nodes = [])
-        arrange_array.add()
-
-        # Place nodes one at a time
-        start_priority = 0
-        grouped_operation = GroupedOperation()
-        found_solution_for_all = True
-        left_over_nodes = []  # nodes that do not fit on an empty build plate
-
-        for idx, (size, node, offset_shape_arr, hull_shape_arr) in enumerate(nodes_arr):
-            # For performance reasons, we assume that when a location does not fit,
-            # it will also not fit for the next object (while what can be untrue).
-
-            try_placement = True
-
-            current_build_plate_number = 0  # always start with the first one
-
-            while try_placement:
-                # make sure that current_build_plate_number is not going crazy or you'll have a lot of arrange objects
-                while current_build_plate_number >= arrange_array.count():
-                    arrange_array.add()
-                arranger = arrange_array.get(current_build_plate_number)
-
-                best_spot = arranger.bestSpot(hull_shape_arr, start_prio=start_priority)
-                x, y = best_spot.x, best_spot.y
-                node.removeDecorator(ZOffsetDecorator)
-                if node.getBoundingBox():
-                    center_y = node.getWorldPosition().y - node.getBoundingBox().bottom
-                else:
-                    center_y = 0
-                if x is not None:  # We could find a place
-                    arranger.place(x, y, offset_shape_arr)  # place the object in the arranger
-
-                    node.callDecoration("setBuildPlateNumber", current_build_plate_number)
-                    grouped_operation.addOperation(TranslateOperation(node, Vector(x, center_y, y), set_position = True))
-                    try_placement = False
-                else:
-                    # very naive, because we skip to the next build plate if one model doesn't fit.
-                    if arranger.isEmpty:
-                        # apparently we can never place this object
-                        left_over_nodes.append(node)
-                        try_placement = False
-                    else:
-                        # try next build plate
-                        current_build_plate_number += 1
-                        try_placement = True
-
-            status_message.setProgress((idx + 1) / len(nodes_arr) * 100)
-            Job.yieldThread()
-
-        for node in left_over_nodes:
-            node.callDecoration("setBuildPlateNumber", -1)  # these are not on any build plate
-            found_solution_for_all = False
-
-        grouped_operation.push()
-
-        status_message.hide()
-
-        if not found_solution_for_all:
-            no_full_solution_message = Message(i18n_catalog.i18nc("@info:status",
-                                                                  "Unable to find a location within the build volume for all objects"),
-                                               title = i18n_catalog.i18nc("@info:title", "Can't Find Location"),
-                                               message_type = Message.MessageType.WARNING)
-            no_full_solution_message.show()

cura/Arranging/ArrangeObjectsJob.py

@@ -21,6 +21,7 @@ class ArrangeObjectsJob(Job):
         self._min_offset = min_offset
 
     def run(self):
+        found_solution_for_all = False
         status_message = Message(i18n_catalog.i18nc("@info:status", "Finding new location for objects"),
                                  lifetime = 0,
                                  dismissable = False,
@@ -28,18 +29,19 @@ class ArrangeObjectsJob(Job):
                                  title = i18n_catalog.i18nc("@info:title", "Finding Location"))
         status_message.show()
 
-        found_solution_for_all = None
         try:
             found_solution_for_all = arrange(self._nodes, Application.getInstance().getBuildVolume(), self._fixed_nodes)
         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.")
 
         status_message.hide()
-        if found_solution_for_all is not None and not found_solution_for_all:
+
+        if not found_solution_for_all:
             no_full_solution_message = Message(
                     i18n_catalog.i18nc("@info:status",
                                        "Unable to find a location within the build volume for all objects"),
                     title = i18n_catalog.i18nc("@info:title", "Can't Find Location"),
                     message_type = Message.MessageType.ERROR)
             no_full_solution_message.show()
+
         self.finished.emit(self)

cura/Arranging/ShapeArray.py

@@ -74,14 +74,14 @@ class ShapeArray:
         # If the child-nodes are included, adjust convex hulls as well:
         if include_children:
             children = node.getAllChildren()
-            if not children is None:
+            if children is not None:
                 for child in children:
                     # 'Inefficient' combination of convex hulls through known code rather than mess it up:
                     child_hull = child.callDecoration("getConvexHull")
-                    if not child_hull is None:
+                    if child_hull is not None:
                         hull_verts = hull_verts.unionConvexHulls(child_hull)
                     child_hull_head = child.callDecoration("getConvexHullHead") or child_hull
-                    if not child_hull_head is None:
+                    if child_hull_head is not None:
                         hull_head_verts = hull_head_verts.unionConvexHulls(child_hull_head)
 
         offset_verts = hull_head_verts.getMinkowskiHull(Polygon.approximatedCircle(min_offset))
@@ -159,4 +159,4 @@ class ShapeArray:
 
         max_col_idx = (idxs[0] - p1[0]) / (p2[0] - p1[0]) * (p2[1] - p1[1]) + p1[1]
         sign = numpy.sign(p2[0] - p1[0])
-        return idxs[1] * sign <= max_col_idx * sign
+        return idxs[1] * sign <= max_col_idx * sign

cura/AutoSave.py

@@ -1,7 +1,7 @@
 # Copyright (c) 2021 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
 
-from PyQt5.QtCore import QTimer
+from PyQt6.QtCore import QTimer
 from typing import Any, TYPE_CHECKING
 
 from UM.Logger import Logger

cura/Backups/Backup.py

@@ -136,7 +136,7 @@ class Backup:
             return False
 
         current_version = Version(self._application.getVersion())
-        version_to_restore = Version(self.meta_data.get("cura_release", "master"))
+        version_to_restore = Version(self.meta_data.get("cura_release", "dev"))
 
         if current_version < version_to_restore:
             # Cannot restore version newer than current because settings might have changed.

cura/BuildVolume.py

@@ -31,7 +31,7 @@ from cura.Settings.GlobalStack import GlobalStack
 from cura.Scene.CuraSceneNode import CuraSceneNode
 from cura.Settings.ExtruderManager import ExtruderManager
 
-from PyQt5.QtCore import QTimer
+from PyQt6.QtCore import QTimer
 
 
 if TYPE_CHECKING:
@@ -565,8 +565,8 @@ class BuildVolume(SceneNode):
         self._updateScaleFactor()
 
         self._volume_aabb = AxisAlignedBox(
-            minimum = Vector(min_w, min_h - 1.0, min_d).scale(self._scale_vector),
-            maximum = Vector(max_w, max_h - self._raft_thickness - self._extra_z_clearance, max_d).scale(self._scale_vector)
+            minimum = Vector(min_w, min_h - 1.0, min_d),
+            maximum = Vector(max_w, max_h - self._raft_thickness - self._extra_z_clearance, max_d)
         )
 
         bed_adhesion_size = self.getEdgeDisallowedSize()
@@ -575,8 +575,8 @@ class BuildVolume(SceneNode):
         # This is probably wrong in all other cases. TODO!
         # The +1 and -1 is added as there is always a bit of extra room required to work properly.
         scale_to_max_bounds = AxisAlignedBox(
-            minimum = Vector(min_w + bed_adhesion_size + 1, min_h, min_d + self._disallowed_area_size - bed_adhesion_size + 1).scale(self._scale_vector),
-            maximum = Vector(max_w - bed_adhesion_size - 1, max_h - self._raft_thickness - self._extra_z_clearance, max_d - self._disallowed_area_size + bed_adhesion_size - 1).scale(self._scale_vector)
+            minimum = Vector(min_w + bed_adhesion_size + 1, min_h, min_d + self._disallowed_area_size - bed_adhesion_size + 1),
+            maximum = Vector(max_w - bed_adhesion_size - 1, max_h - self._raft_thickness - self._extra_z_clearance, max_d - self._disallowed_area_size + bed_adhesion_size - 1)
         )
 
         self._application.getController().getScene()._maximum_bounds = scale_to_max_bounds  # type: ignore
@@ -645,7 +645,7 @@ class BuildVolume(SceneNode):
             for extruder in extruders:
                 extruder.propertyChanged.connect(self._onSettingPropertyChanged)
 
-            self._width = self._global_container_stack.getProperty("machine_width", "value") * self._scale_vector.x
+            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)
@@ -656,7 +656,7 @@ class BuildVolume(SceneNode):
             else:
                 self._height = self._global_container_stack.getProperty("machine_height", "value")
                 self._build_volume_message.hide()
-            self._depth = self._global_container_stack.getProperty("machine_depth", "value") * self._scale_vector.y
+            self._depth = self._global_container_stack.getProperty("machine_depth", "value")
             self._shape = self._global_container_stack.getProperty("machine_shape", "value")
 
             self._updateDisallowedAreas()
@@ -752,8 +752,8 @@ class BuildVolume(SceneNode):
             return
         self._updateScaleFactor()
         self._height = self._global_container_stack.getProperty("machine_height", "value") * self._scale_vector.z
-        self._width = self._global_container_stack.getProperty("machine_width", "value") * self._scale_vector.x
-        self._depth = self._global_container_stack.getProperty("machine_depth", "value") * self._scale_vector.y
+        self._width = self._global_container_stack.getProperty("machine_width", "value")
+        self._depth = self._global_container_stack.getProperty("machine_depth", "value")
         self._shape = self._global_container_stack.getProperty("machine_shape", "value")
 
     def _updateDisallowedAreasAndRebuild(self):
@@ -770,14 +770,6 @@ class BuildVolume(SceneNode):
         self._extra_z_clearance = self._calculateExtraZClearance(ExtruderManager.getInstance().getUsedExtruderStacks())
         self.rebuild()
 
-    def _scaleAreas(self, result_areas: List[Polygon]) -> None:
-        if self._global_container_stack is None:
-            return
-        for i, polygon in enumerate(result_areas):
-            result_areas[i] = polygon.scale(
-                100.0 / max(100.0, self._global_container_stack.getProperty("material_shrinkage_percentage_xy", "value"))
-            )
-
     def _updateDisallowedAreas(self) -> None:
         if not self._global_container_stack:
             return
@@ -818,11 +810,6 @@ class BuildVolume(SceneNode):
                             break
                     if prime_tower_collision:  # Already found a collision.
                         break
-                    if self._global_container_stack.getProperty("prime_tower_brim_enable", "value") and self._global_container_stack.getProperty("adhesion_type", "value") != "raft":
-                        brim_size = self._calculateBedAdhesionSize(used_extruders, "brim")
-                        # Use 2x the brim size, since we need 1x brim size distance due to the object brim and another
-                        # times the brim due to the brim of the prime tower
-                        prime_tower_areas[extruder_id][area_index] = prime_tower_area.getMinkowskiHull(Polygon.approximatedCircle(2 * brim_size, num_segments = 24))
                 if not prime_tower_collision:
                     result_areas[extruder_id].extend(prime_tower_areas[extruder_id])
                     result_areas_no_brim[extruder_id].extend(prime_tower_areas[extruder_id])
@@ -833,11 +820,9 @@ class BuildVolume(SceneNode):
 
         self._disallowed_areas = []
         for extruder_id in result_areas:
-            self._scaleAreas(result_areas[extruder_id])
             self._disallowed_areas.extend(result_areas[extruder_id])
         self._disallowed_areas_no_brim = []
         for extruder_id in result_areas_no_brim:
-            self._scaleAreas(result_areas_no_brim[extruder_id])
             self._disallowed_areas_no_brim.extend(result_areas_no_brim[extruder_id])
 
     def _computeDisallowedAreasPrinted(self, used_extruders):
@@ -850,9 +835,13 @@ class BuildVolume(SceneNode):
 
         result = {}
         skirt_brim_extruder: ExtruderStack = None
+        skirt_brim_extruder_nr = self._global_container_stack.getProperty("skirt_brim_extruder_nr", "value")
+
         for extruder in used_extruders:
-            if int(extruder.getProperty("extruder_nr", "value")) == int(self._global_container_stack.getProperty("skirt_brim_extruder_nr", "value")):
-                skirt_brim_extruder = extruder
+            if skirt_brim_extruder_nr == -1:
+                skirt_brim_extruder = used_extruders[0]  # The prime tower brim is always printed with the first extruder
+            elif int(extruder.getProperty("extruder_nr", "value")) == int(skirt_brim_extruder_nr):
+                    skirt_brim_extruder = extruder
             result[extruder.getId()] = []
 
         # Currently, the only normally printed object is the prime tower.
@@ -866,15 +855,6 @@ class BuildVolume(SceneNode):
                 prime_tower_x = prime_tower_x - machine_width / 2 #Offset by half machine_width and _depth to put the origin in the front-left.
                 prime_tower_y = prime_tower_y + machine_depth / 2
 
-            if skirt_brim_extruder is not None and self._global_container_stack.getProperty("prime_tower_brim_enable", "value") and self._global_container_stack.getProperty("adhesion_type", "value") != "raft":
-                brim_size = (
-                    skirt_brim_extruder.getProperty("brim_line_count", "value") *
-                    skirt_brim_extruder.getProperty("skirt_brim_line_width", "value") / 100.0 *
-                    skirt_brim_extruder.getProperty("initial_layer_line_width_factor", "value")
-                )
-                prime_tower_x -= brim_size
-                prime_tower_y += brim_size
-
             radius = prime_tower_size / 2
             prime_tower_area = Polygon.approximatedCircle(radius, num_segments = 24)
             prime_tower_area = prime_tower_area.translate(prime_tower_x - radius, prime_tower_y - radius)
@@ -993,6 +973,9 @@ class BuildVolume(SceneNode):
             half_machine_width = self._global_container_stack.getProperty("machine_width", "value") / 2
             half_machine_depth = self._global_container_stack.getProperty("machine_depth", "value") / 2
 
+            # We need at a minimum a very small border around the edge so that models can't go off the build plate
+            border_size = max(border_size, 0.1)
+
             if self._shape != "elliptic":
                 if border_size - left_unreachable_border > 0:
                     result[extruder_id].append(Polygon(numpy.array([
@@ -1083,7 +1066,7 @@ class BuildVolume(SceneNode):
                 all_values[i] = 0
         return all_values
 
-    def _calculateBedAdhesionSize(self, used_extruders, adhesion_override = None):
+    def _calculateBedAdhesionSize(self, used_extruders):
         """Get the bed adhesion size for the global container stack and used extruders
 
         :param adhesion_override: override adhesion type.
@@ -1093,51 +1076,12 @@ class BuildVolume(SceneNode):
             return None
 
         container_stack = self._global_container_stack
-        adhesion_type = adhesion_override
-        if adhesion_type is None:
-            adhesion_type = container_stack.getProperty("adhesion_type", "value")
+        adhesion_type = container_stack.getProperty("adhesion_type", "value")
 
-        # Skirt_brim_line_width is a bit of an odd one out. The primary bit of the skirt/brim is printed
-        # with the adhesion extruder, but it also prints one extra line by all other extruders. As such, the
-        # setting does *not* have a limit_to_extruder setting (which means that we can't ask the global extruder what
-        # the value is.
-        skirt_brim_extruder_nr = self._global_container_stack.getProperty("skirt_brim_extruder_nr", "value")
-        try:
-            skirt_brim_stack = self._global_container_stack.extruderList[int(skirt_brim_extruder_nr)]
-        except IndexError:
-            Logger.warning(f"Couldn't find extruder with index '{skirt_brim_extruder_nr}', defaulting to 0 instead.")
-            skirt_brim_stack = self._global_container_stack.extruderList[0]
-        skirt_brim_line_width = skirt_brim_stack.getProperty("skirt_brim_line_width", "value")
-
-        initial_layer_line_width_factor = skirt_brim_stack.getProperty("initial_layer_line_width_factor", "value")
-        # Use brim width if brim is enabled OR the prime tower has a brim.
-        if adhesion_type == "brim":
-            brim_line_count = skirt_brim_stack.getProperty("brim_line_count", "value")
-            bed_adhesion_size = skirt_brim_line_width * brim_line_count * initial_layer_line_width_factor / 100.0
-
-            for extruder_stack in used_extruders:
-                bed_adhesion_size += extruder_stack.getProperty("skirt_brim_line_width", "value") * extruder_stack.getProperty("initial_layer_line_width_factor", "value") / 100.0
-
-            # We don't create an additional line for the extruder we're printing the brim with.
-            bed_adhesion_size -= skirt_brim_line_width * initial_layer_line_width_factor / 100.0
-        elif adhesion_type == "skirt":
-            skirt_distance = skirt_brim_stack.getProperty("skirt_gap", "value")
-            skirt_line_count = skirt_brim_stack.getProperty("skirt_line_count", "value")
-
-            bed_adhesion_size = skirt_distance + (
-                        skirt_brim_line_width * skirt_line_count) * initial_layer_line_width_factor / 100.0
-
-            for extruder_stack in used_extruders:
-                bed_adhesion_size += extruder_stack.getProperty("skirt_brim_line_width", "value") * extruder_stack.getProperty("initial_layer_line_width_factor", "value") / 100.0
-
-            # We don't create an additional line for the extruder we're printing the skirt with.
-            bed_adhesion_size -= skirt_brim_line_width * initial_layer_line_width_factor / 100.0
-        elif adhesion_type == "raft":
+        if adhesion_type == "raft":
             bed_adhesion_size = self._global_container_stack.getProperty("raft_margin", "value")  # Should refer to the raft extruder if set.
-        elif adhesion_type == "none":
+        else:  # raft, brim or skirt. Those last two are handled by CuraEngine.
             bed_adhesion_size = 0
-        else:
-            raise Exception("Unknown bed adhesion type. Did you forget to update the build volume calculations for your new bed adhesion type?")
 
         max_length_available = 0.5 * min(
             self._global_container_stack.getProperty("machine_width", "value"),
@@ -1214,7 +1158,7 @@ class BuildVolume(SceneNode):
         return max(min(value, max_value), min_value)
 
     _machine_settings = ["machine_width", "machine_depth", "machine_height", "machine_shape", "machine_center_is_zero"]
-    _skirt_settings = ["adhesion_type", "skirt_gap", "skirt_line_count", "skirt_brim_line_width", "brim_width", "brim_line_count", "raft_margin", "draft_shield_enabled", "draft_shield_dist", "initial_layer_line_width_factor"]
+    _skirt_settings = ["adhesion_type", "skirt_gap", "skirt_line_count", "skirt_brim_line_width", "brim_gap", "brim_width", "brim_line_count", "raft_margin", "draft_shield_enabled", "draft_shield_dist", "initial_layer_line_width_factor"]
     _raft_settings = ["adhesion_type", "raft_base_thickness", "raft_interface_layers", "raft_interface_thickness", "raft_surface_layers", "raft_surface_thickness", "raft_airgap", "layer_0_z_overlap"]
     _extra_z_settings = ["retraction_hop_enabled", "retraction_hop"]
     _prime_settings = ["extruder_prime_pos_x", "extruder_prime_pos_y", "prime_blob_enable"]

cura/CameraAnimation.py

@@ -2,8 +2,8 @@
 # Cura is released under the terms of the LGPLv3 or higher.
 
 
-from PyQt5.QtCore import QVariantAnimation, QEasingCurve
-from PyQt5.QtGui import QVector3D
+from PyQt6.QtCore import QVariantAnimation, QEasingCurve
+from PyQt6.QtGui import QVector3D
 
 from UM.Math.Vector import Vector
 
@@ -13,7 +13,7 @@ class CameraAnimation(QVariantAnimation):
         super().__init__(parent)
         self._camera_tool = None
         self.setDuration(300)
-        self.setEasingCurve(QEasingCurve.OutQuad)
+        self.setEasingCurve(QEasingCurve.Type.OutQuad)
 
     def setCameraTool(self, camera_tool):
         self._camera_tool = camera_tool

cura/CrashHandler.py

@@ -1,5 +1,5 @@
-# Copyright (c) 2019 Ultimaker B.V.
-# Cura is released under the terms of the LGPLv3 or higher.
+#  Copyright (c) 2022 UltiMaker
+#  Cura is released under the terms of the LGPLv3 or higher.
 
 import platform
 import traceback
@@ -20,9 +20,9 @@ try:
 except ImportError:
     with_sentry_sdk = False
 
-from PyQt5.QtCore import QT_VERSION_STR, PYQT_VERSION_STR, QUrl
-from PyQt5.QtWidgets import QDialog, QDialogButtonBox, QVBoxLayout, QLabel, QTextEdit, QGroupBox, QCheckBox, QPushButton
-from PyQt5.QtGui import QDesktopServices
+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 UM.Application import Application
 from UM.Logger import Logger
@@ -110,7 +110,7 @@ class CrashHandler:
         layout = QVBoxLayout(dialog)
 
         label = QLabel()
-        label.setText(catalog.i18nc("@label crash message", """<p><b>Oops, Ultimaker Cura has encountered something that doesn't seem right.</p></b>
+        label.setText(catalog.i18nc("@label crash message", """<p><b>Oops, UltiMaker Cura has encountered something that doesn't seem right.</p></b>
                     <p>We encountered an unrecoverable error during start up. It was possibly caused by some incorrect configuration files. We suggest to backup and reset your configuration.</p>
                     <p>Backups can be found in the configuration folder.</p>
                     <p>Please send us this Crash Report to fix the problem.</p>
@@ -119,7 +119,7 @@ class CrashHandler:
         layout.addWidget(label)
 
         # "send report" check box and show details
-        self._send_report_checkbox = QCheckBox(catalog.i18nc("@action:button", "Send crash report to Ultimaker"), dialog)
+        self._send_report_checkbox = QCheckBox(catalog.i18nc("@action:button", "Send crash report to UltiMaker"), dialog)
         self._send_report_checkbox.setChecked(True)
 
         show_details_button = QPushButton(catalog.i18nc("@action:button", "Show detailed crash report"), dialog)
@@ -136,8 +136,8 @@ class CrashHandler:
 
         # "backup and start clean" and "close" buttons
         buttons = QDialogButtonBox()
-        buttons.addButton(QDialogButtonBox.Close)
-        buttons.addButton(catalog.i18nc("@action:button", "Backup and Reset Configuration"), QDialogButtonBox.AcceptRole)
+        buttons.addButton(QDialogButtonBox.StandardButton.Close)
+        buttons.addButton(catalog.i18nc("@action:button", "Backup and Reset Configuration"), QDialogButtonBox.ButtonRole.AcceptRole)
         buttons.rejected.connect(self._closeEarlyCrashDialog)
         buttons.accepted.connect(self._backupAndStartClean)
 
@@ -161,7 +161,7 @@ class CrashHandler:
         QDesktopServices.openUrl(QUrl.fromLocalFile( path ))
 
     def _showDetailedReport(self):
-        self.dialog.exec_()
+        self.dialog.exec()
 
     def _createDialog(self):
         """Creates a modal dialog."""
@@ -261,7 +261,7 @@ class CrashHandler:
         opengl_instance = OpenGL.getInstance()
         if not opengl_instance:
             self.data["opengl"] = {"version": "n/a", "vendor": "n/a", "type": "n/a"}
-            return catalog.i18nc("@label", "Not yet initialized<br/>")
+            return catalog.i18nc("@label", "Not yet initialized") + "<br />"
 
         info = "<ul>"
         info += catalog.i18nc("@label OpenGL version", "<li>OpenGL Version: {version}</li>").format(version = opengl_instance.getOpenGLVersion())
@@ -291,6 +291,7 @@ class CrashHandler:
         if with_sentry_sdk:
             with configure_scope() as scope:
                 scope.set_tag("opengl_version", opengl_instance.getOpenGLVersion())
+                scope.set_tag("opengl_version_short", opengl_instance.getOpenGLVersionShort())
                 scope.set_tag("gpu_vendor", opengl_instance.getGPUVendorName())
                 scope.set_tag("gpu_type", opengl_instance.getGPUType())
                 scope.set_tag("active_machine", active_machine_definition_id)
@@ -409,12 +410,12 @@ class CrashHandler:
 
     def _buttonsWidget(self):
         buttons = QDialogButtonBox()
-        buttons.addButton(QDialogButtonBox.Close)
+        buttons.addButton(QDialogButtonBox.StandardButton.Close)
         # Like above, this will be served as a separate detailed report dialog if the application has not yet been
         # fully loaded. In this case, "send report" will be a check box in the early crash dialog, so there is no
         # need for this extra button.
         if self.has_started:
-            buttons.addButton(catalog.i18nc("@action:button", "Send report"), QDialogButtonBox.AcceptRole)
+            buttons.addButton(catalog.i18nc("@action:button", "Send report"), QDialogButtonBox.ButtonRole.AcceptRole)
             buttons.accepted.connect(self._sendCrashReport)
         buttons.rejected.connect(self.dialog.close)
 
@@ -456,5 +457,5 @@ class CrashHandler:
     def _show(self):
         # When the exception is in the skip_exception_types list, the dialog is not created, so we don't need to show it
         if self.dialog:
-            self.dialog.exec_()
+            self.dialog.exec()
         os._exit(1)

cura/CuraActions.py

@@ -1,8 +1,8 @@
 # Copyright (c) 2018 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
 
-from PyQt5.QtCore import QObject, QUrl
-from PyQt5.QtGui import QDesktopServices
+from PyQt6.QtCore import QObject, QUrl
+from PyQt6.QtGui import QDesktopServices
 from typing import List, cast
 
 from UM.Event import CallFunctionEvent

cura/CuraApplication.py

@@ -1,6 +1,6 @@
-# Copyright (c) 2021 Ultimaker B.V.
+# Copyright (c) 2022 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
-
+import enum
 import os
 import sys
 import tempfile
@@ -8,10 +8,10 @@ import time
 from typing import cast, TYPE_CHECKING, Optional, Callable, List, Any, Dict
 
 import numpy
-from PyQt5.QtCore import QObject, QTimer, QUrl, pyqtSignal, pyqtProperty, QEvent, Q_ENUMS
-from PyQt5.QtGui import QColor, QIcon
-from PyQt5.QtQml import qmlRegisterUncreatableType, qmlRegisterSingletonType, qmlRegisterType
-from PyQt5.QtWidgets import QMessageBox
+from PyQt6.QtCore import QObject, QTimer, QUrl, pyqtSignal, pyqtProperty, QEvent, pyqtEnum, QCoreApplication
+from PyQt6.QtGui import QColor, QIcon
+from PyQt6.QtQml import qmlRegisterUncreatableType, qmlRegisterUncreatableMetaObject, qmlRegisterSingletonType, qmlRegisterType
+from PyQt6.QtWidgets import QMessageBox
 
 import UM.Util
 import cura.Settings.cura_empty_instance_containers
@@ -43,7 +43,7 @@ from UM.Scene.Selection import Selection
 from UM.Scene.ToolHandle import ToolHandle
 from UM.Settings.ContainerRegistry import ContainerRegistry
 from UM.Settings.InstanceContainer import InstanceContainer
-from UM.Settings.SettingDefinition import SettingDefinition, DefinitionPropertyType
+from UM.Settings.SettingDefinition import SettingDefinition, DefinitionPropertyType, toIntConversion
 from UM.Settings.SettingFunction import SettingFunction
 from UM.Settings.Validator import Validator
 from UM.View.SelectionPass import SelectionPass  # For typing.
@@ -52,8 +52,6 @@ from UM.i18n import i18nCatalog
 from cura import ApplicationMetadata
 from cura.API import CuraAPI
 from cura.API.Account import Account
-from cura.Arranging.Arrange import Arrange
-from cura.Arranging.ArrangeObjectsAllBuildPlatesJob import ArrangeObjectsAllBuildPlatesJob
 from cura.Arranging.ArrangeObjectsJob import ArrangeObjectsJob
 from cura.Arranging.Nest2DArrange import arrange
 from cura.Machines.MachineErrorChecker import MachineErrorChecker
@@ -117,6 +115,10 @@ from . import CuraActions
 from . import PlatformPhysics
 from . import PrintJobPreviewImageProvider
 from .AutoSave import AutoSave
+from .Machines.Models.CompatibleMachineModel import CompatibleMachineModel
+from .Machines.Models.MachineListModel import MachineListModel
+from .Machines.Models.ActiveIntentQualitiesModel import ActiveIntentQualitiesModel
+from .Machines.Models.IntentSelectionModel import IntentSelectionModel
 from .SingleInstance import SingleInstance
 
 if TYPE_CHECKING:
@@ -124,16 +126,15 @@ if TYPE_CHECKING:
 
 numpy.seterr(all = "ignore")
 
-
 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 = 19
+    SettingVersion = 20
 
     Created = False
 
-    class ResourceTypes:
+    class ResourceTypes(enum.IntEnum):
         QmlFiles = Resources.UserType + 1
         Firmware = Resources.UserType + 2
         QualityInstanceContainer = Resources.UserType + 3
@@ -147,12 +148,13 @@ class CuraApplication(QtApplication):
         SettingVisibilityPreset = Resources.UserType + 11
         IntentInstanceContainer = Resources.UserType + 12
 
-    Q_ENUMS(ResourceTypes)
+    pyqtEnum(ResourceTypes)
 
     def __init__(self, *args, **kwargs):
         super().__init__(name = ApplicationMetadata.CuraAppName,
                          app_display_name = ApplicationMetadata.CuraAppDisplayName,
                          version = ApplicationMetadata.CuraVersion if not ApplicationMetadata.IsAlternateVersion else ApplicationMetadata.CuraBuildType,
+                         latest_url = ApplicationMetadata.CuraLatestURL,
                          api_version = ApplicationMetadata.CuraSDKVersion,
                          build_type = ApplicationMetadata.CuraBuildType,
                          is_debug_mode = ApplicationMetadata.CuraDebugMode,
@@ -260,6 +262,7 @@ class CuraApplication(QtApplication):
 
         from UM.CentralFileStorage import CentralFileStorage
         CentralFileStorage.setIsEnterprise(ApplicationMetadata.IsEnterpriseVersion)
+        Resources.setIsEnterprise(ApplicationMetadata.IsEnterpriseVersion)
 
     @pyqtProperty(str, constant=True)
     def ultimakerCloudApiRootUrl(self) -> str:
@@ -318,7 +321,7 @@ class CuraApplication(QtApplication):
     def initialize(self) -> None:
         self.__addExpectedResourceDirsAndSearchPaths()  # Must be added before init of super
 
-        super().initialize()
+        super().initialize(ApplicationMetadata.IsEnterpriseVersion)
 
         self._preferences.addPreference("cura/single_instance", False)
         self._use_single_instance = self._preferences.getValue("cura/single_instance") or self._cli_args.single_instance
@@ -351,12 +354,18 @@ class CuraApplication(QtApplication):
             Resources.addExpectedDirNameInData(dir_name)
 
         app_root = os.path.abspath(os.path.join(os.path.dirname(sys.executable)))
-        Resources.addSearchPath(os.path.join(app_root, "share", "cura", "resources"))
+        Resources.addSecureSearchPath(os.path.join(app_root, "share", "cura", "resources"))
 
-        Resources.addSearchPath(os.path.join(self._app_install_dir, "share", "cura", "resources"))
+        Resources.addSecureSearchPath(os.path.join(self._app_install_dir, "share", "cura", "resources"))
         if not hasattr(sys, "frozen"):
-            resource_path = os.path.join(os.path.abspath(os.path.dirname(__file__)), "..", "resources")
-            Resources.addSearchPath(resource_path)
+            Resources.addSearchPath(os.path.join(os.path.abspath(os.path.dirname(__file__)), "..", "resources"))
+
+            # local Conan cache
+            Resources.addSearchPath(os.path.join(os.path.abspath(os.path.dirname(__file__)), "..", "..", "resources"))
+            Resources.addSearchPath(os.path.join(os.path.abspath(os.path.dirname(__file__)), "..", "..", "plugins"))
+
+            # venv site-packages
+            Resources.addSearchPath(os.path.join(app_root, "..", "share", "cura", "resources"))
 
     @classmethod
     def _initializeSettingDefinitions(cls):
@@ -382,11 +391,12 @@ class CuraApplication(QtApplication):
         SettingDefinition.addSupportedProperty("resolve", DefinitionPropertyType.Function, default=None,
                                                depends_on="value")
 
-        SettingDefinition.addSettingType("extruder", None, str, Validator)
-        SettingDefinition.addSettingType("optional_extruder", None, str, None)
+        SettingDefinition.addSettingType("extruder", None, toIntConversion, Validator)
+        SettingDefinition.addSettingType("optional_extruder", None, toIntConversion, None)
         SettingDefinition.addSettingType("[int]", None, str, None)
 
 
+
     def _initializeSettingFunctions(self):
         """Adds custom property types, settings types, and extra operators (functions).
 
@@ -623,11 +633,14 @@ class CuraApplication(QtApplication):
         # the QML code then gets `null` as the global stack and can deal with that as it deems fit.
         self.getMachineManager().setActiveMachine(None)
 
+        QtApplication.getInstance().closeAllWindows()
+
         main_window = self.getMainWindow()
         if main_window is not None:
             main_window.close()
-        else:
-            self.exit(0)
+
+        QtApplication.closeAllWindows()
+        QCoreApplication.quit()
 
     # This function first performs all upon-exit checks such as USB printing that is in progress.
     # Use this to close the application.
@@ -679,7 +692,24 @@ class CuraApplication(QtApplication):
         self._setLoadingHint(self._i18n_catalog.i18nc("@info:progress", "Initializing Active Machine..."))
         super().setGlobalContainerStack(stack)
 
+    showMessageBox = pyqtSignal(str,str, str, str, int, int,
+                                arguments = ["title", "text", "informativeText", "detailedText","buttons", "icon"])
+    """A reusable dialogbox"""
+
+    def messageBox(self, title, text,
+                   informativeText = "",
+                   detailedText = "",
+                   buttons = QMessageBox.StandardButton.Ok,
+                   icon = QMessageBox.Icon.NoIcon,
+                   callback = None,
+                   callback_arguments = []
+                   ):
+        self._message_box_callback = callback
+        self._message_box_callback_arguments = callback_arguments
+        self.showMessageBox.emit(title, text, informativeText, detailedText, buttons, icon)
+
     showDiscardOrKeepProfileChanges = pyqtSignal()
+    showCompareAndSaveProfileChanges = pyqtSignal(int)
 
     def discardOrKeepProfileChanges(self) -> bool:
         has_user_interaction = False
@@ -794,6 +824,12 @@ class CuraApplication(QtApplication):
     def run(self):
         super().run()
 
+        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"]))
+        else:
+            Logger.warning("Could not find conan_install_info.json")
+
         Logger.log("i", "Initializing machine error checker")
         self._machine_error_checker = MachineErrorChecker(self)
         self._machine_error_checker.initialize()
@@ -818,9 +854,6 @@ class CuraApplication(QtApplication):
         root = self.getController().getScene().getRoot()
         self._volume = BuildVolume.BuildVolume(self, root)
 
-        # Ensure that the old style arranger still works.
-        Arrange.build_volume = self._volume
-
         # initialize info objects
         self._print_information = PrintInformation.PrintInformation(self)
         self._cura_actions = CuraActions.CuraActions(self)
@@ -862,7 +895,7 @@ class CuraApplication(QtApplication):
         self._auto_save = AutoSave(self)
         self._auto_save.initialize()
 
-        self.exec_()
+        self.exec()
 
     def __setUpSingleInstanceServer(self):
         if self._use_single_instance:
@@ -928,6 +961,7 @@ class CuraApplication(QtApplication):
         self._qml_import_paths.append(Resources.getPath(self.ResourceTypes.QmlFiles))
         self._setLoadingHint(self._i18n_catalog.i18nc("@info:progress", "Initializing engine..."))
         self.initializeEngine()
+        self.getTheme().setCheckIfTrusted(ApplicationMetadata.IsEnterpriseVersion)
 
         # Initialize UI state
         controller.setActiveStage("PrepareStage")
@@ -1079,12 +1113,18 @@ class CuraApplication(QtApplication):
     def event(self, event):
         """Handle Qt events"""
 
-        if event.type() == QEvent.FileOpen:
+        if event.type() == QEvent.Type.FileOpen:
             if self._plugins_loaded:
                 self._openFile(event.file())
             else:
                 self._open_file_queue.append(event.file())
 
+        if int(event.type()) == 20:  # 'QEvent.Type.Quit' enum isn't there, even though it should be according to docs.
+            # Once we're at this point, everything should have been flushed already (past OnExitCallbackManager).
+            # It's more difficult to call sys.exit(0): That requires that it happens as the result of a pyqtSignal-emit.
+            # (See https://doc.qt.io/qt-6/qcoreapplication.html#quit)
+            os._exit(0)
+
         return super().event(event)
 
     def getAutoSave(self) -> Optional[AutoSave]:
@@ -1125,16 +1165,16 @@ class CuraApplication(QtApplication):
         engine.rootContext().setContextProperty("CuraSDKVersion", ApplicationMetadata.CuraSDKVersion)
 
         self.processEvents()
-        qmlRegisterUncreatableType(CuraApplication, "Cura", 1, 0, "ResourceTypes", "Just an Enum type")
+        qmlRegisterUncreatableMetaObject(CuraApplication.staticMetaObject, "Cura", 1, 0, "ResourceTypes", "ResourceTypes is an enum-only type")
 
         self.processEvents()
-        qmlRegisterSingletonType(CuraSceneController, "Cura", 1, 0, "SceneController", self.getCuraSceneController)
-        qmlRegisterSingletonType(ExtruderManager, "Cura", 1, 0, "ExtruderManager", self.getExtruderManager)
-        qmlRegisterSingletonType(MachineManager, "Cura", 1, 0, "MachineManager", self.getMachineManager)
-        qmlRegisterSingletonType(IntentManager, "Cura", 1, 6, "IntentManager", self.getIntentManager)
-        qmlRegisterSingletonType(SettingInheritanceManager, "Cura", 1, 0, "SettingInheritanceManager", self.getSettingInheritanceManager)
-        qmlRegisterSingletonType(SimpleModeSettingsManager, "Cura", 1, 0, "SimpleModeSettingsManager", self.getSimpleModeSettingsManager)
-        qmlRegisterSingletonType(MachineActionManager.MachineActionManager, "Cura", 1, 0, "MachineActionManager", self.getMachineActionManager)
+        qmlRegisterSingletonType(CuraSceneController, "Cura", 1, 0, self.getCuraSceneController, "SceneController")
+        qmlRegisterSingletonType(ExtruderManager, "Cura", 1, 0, self.getExtruderManager, "ExtruderManager")
+        qmlRegisterSingletonType(MachineManager, "Cura", 1, 0, self.getMachineManager, "MachineManager")
+        qmlRegisterSingletonType(IntentManager, "Cura", 1, 6, self.getIntentManager, "IntentManager")
+        qmlRegisterSingletonType(SettingInheritanceManager, "Cura", 1, 0, self.getSettingInheritanceManager, "SettingInheritanceManager")
+        qmlRegisterSingletonType(SimpleModeSettingsManager, "Cura", 1, 0, self.getSimpleModeSettingsManager, "SimpleModeSettingsManager")
+        qmlRegisterSingletonType(MachineActionManager.MachineActionManager, "Cura", 1, 0, self.getMachineActionManager, "MachineActionManager")
 
         self.processEvents()
         qmlRegisterType(NetworkingUtil, "Cura", 1, 5, "NetworkingUtil")
@@ -1152,24 +1192,28 @@ class CuraApplication(QtApplication):
         qmlRegisterType(InstanceContainer, "Cura", 1, 0, "InstanceContainer")
         qmlRegisterType(ExtrudersModel, "Cura", 1, 0, "ExtrudersModel")
         qmlRegisterType(GlobalStacksModel, "Cura", 1, 0, "GlobalStacksModel")
+        qmlRegisterType(MachineListModel, "Cura", 1, 0, "MachineListModel")
+        qmlRegisterType(CompatibleMachineModel, "Cura", 1, 0, "CompatibleMachineModel")
 
         self.processEvents()
         qmlRegisterType(FavoriteMaterialsModel, "Cura", 1, 0, "FavoriteMaterialsModel")
         qmlRegisterType(GenericMaterialsModel, "Cura", 1, 0, "GenericMaterialsModel")
         qmlRegisterType(MaterialBrandsModel, "Cura", 1, 0, "MaterialBrandsModel")
-        qmlRegisterSingletonType(QualityManagementModel, "Cura", 1, 0, "QualityManagementModel", self.getQualityManagementModel)
-        qmlRegisterSingletonType(MaterialManagementModel, "Cura", 1, 5, "MaterialManagementModel", self.getMaterialManagementModel)
+        qmlRegisterSingletonType(QualityManagementModel, "Cura", 1, 0, self.getQualityManagementModel, "QualityManagementModel")
+        qmlRegisterSingletonType(MaterialManagementModel, "Cura", 1, 5, self.getMaterialManagementModel, "MaterialManagementModel")
 
         self.processEvents()
         qmlRegisterType(DiscoveredPrintersModel, "Cura", 1, 0, "DiscoveredPrintersModel")
         qmlRegisterType(DiscoveredCloudPrintersModel, "Cura", 1, 7, "DiscoveredCloudPrintersModel")
         qmlRegisterSingletonType(QualityProfilesDropDownMenuModel, "Cura", 1, 0,
-                                 "QualityProfilesDropDownMenuModel", self.getQualityProfilesDropDownMenuModel)
+                                 self.getQualityProfilesDropDownMenuModel, "QualityProfilesDropDownMenuModel")
         qmlRegisterSingletonType(CustomQualityProfilesDropDownMenuModel, "Cura", 1, 0,
-                                 "CustomQualityProfilesDropDownMenuModel", self.getCustomQualityProfilesDropDownMenuModel)
+                                 self.getCustomQualityProfilesDropDownMenuModel, "CustomQualityProfilesDropDownMenuModel")
         qmlRegisterType(NozzleModel, "Cura", 1, 0, "NozzleModel")
         qmlRegisterType(IntentModel, "Cura", 1, 6, "IntentModel")
         qmlRegisterType(IntentCategoryModel, "Cura", 1, 6, "IntentCategoryModel")
+        qmlRegisterType(IntentSelectionModel, "Cura", 1, 7, "IntentSelectionModel")
+        qmlRegisterType(ActiveIntentQualitiesModel, "Cura", 1, 7, "ActiveIntentQualitiesModel")
 
         self.processEvents()
         qmlRegisterType(MaterialSettingsVisibilityHandler, "Cura", 1, 0, "MaterialSettingsVisibilityHandler")
@@ -1178,14 +1222,14 @@ class CuraApplication(QtApplication):
         qmlRegisterType(FirstStartMachineActionsModel, "Cura", 1, 0, "FirstStartMachineActionsModel")
         qmlRegisterType(MachineNameValidator, "Cura", 1, 0, "MachineNameValidator")
         qmlRegisterType(UserChangesModel, "Cura", 1, 0, "UserChangesModel")
-        qmlRegisterSingletonType(ContainerManager, "Cura", 1, 0, "ContainerManager", ContainerManager.getInstance)
+        qmlRegisterSingletonType(ContainerManager, "Cura", 1, 0, ContainerManager.getInstance, "ContainerManager")
         qmlRegisterType(SidebarCustomMenuItemsModel, "Cura", 1, 0, "SidebarCustomMenuItemsModel")
 
         qmlRegisterType(PrinterOutputDevice, "Cura", 1, 0, "PrinterOutputDevice")
 
         from cura.API import CuraAPI
-        qmlRegisterSingletonType(CuraAPI, "Cura", 1, 1, "API", self.getCuraAPI)
-        qmlRegisterUncreatableType(Account, "Cura", 1, 0, "AccountSyncState", "Could not create AccountSyncState")
+        qmlRegisterSingletonType(CuraAPI, "Cura", 1, 1, self.getCuraAPI, "API")
+        qmlRegisterUncreatableMetaObject(CuraApplication.staticMetaObject, "Cura", 1, 0, "AccountSyncState", "AccountSyncState is an enum-only type")
 
         # As of Qt5.7, it is necessary to get rid of any ".." in the path for the singleton to work.
         actions_url = QUrl.fromLocalFile(os.path.abspath(Resources.getPath(CuraApplication.ResourceTypes.QmlFiles, "Actions.qml")))
@@ -1376,33 +1420,6 @@ class CuraApplication(QtApplication):
                 op.addOperation(SetTransformOperation(node, Vector(0, center_y, 0), Quaternion(), Vector(1, 1, 1)))
             op.push()
 
-    @pyqtSlot()
-    def arrangeObjectsToAllBuildPlates(self) -> None:
-        """Arrange all objects."""
-
-        nodes_to_arrange = []
-        for node in DepthFirstIterator(self.getController().getScene().getRoot()):
-            if not isinstance(node, SceneNode):
-                continue
-
-            if not node.getMeshData() and not node.callDecoration("isGroup"):
-                continue  # Node that doesn't have a mesh and is not a group.
-
-            parent_node = node.getParent()
-            if parent_node and parent_node.callDecoration("isGroup"):
-                continue  # Grouped nodes don't need resetting as their parent (the group) is reset)
-
-            if not node.callDecoration("isSliceable") and not node.callDecoration("isGroup"):
-                continue  # i.e. node with layer data
-
-            bounding_box = node.getBoundingBox()
-            # Skip nodes that are too big
-            if bounding_box is None or bounding_box.width < self._volume.getBoundingBox().width or bounding_box.depth < self._volume.getBoundingBox().depth:
-                nodes_to_arrange.append(node)
-        job = ArrangeObjectsAllBuildPlatesJob(nodes_to_arrange)
-        job.start()
-        self.getCuraSceneController().setActiveBuildPlate(0)  # Select first build plate
-
     # Single build plate
     @pyqtSlot()
     def arrangeAll(self) -> None:
@@ -1431,7 +1448,7 @@ class CuraApplication(QtApplication):
                 bounding_box = node.getBoundingBox()
                 if bounding_box is None or bounding_box.width < self._volume.getBoundingBox().width or bounding_box.depth < self._volume.getBoundingBox().depth:
                     # Arrange only the unlocked nodes and keep the locked ones in place
-                    if UM.Util.parseBool(node.getSetting(SceneNodeSettings.LockPosition)):
+                    if node.getSetting(SceneNodeSettings.LockPosition):
                         locked_nodes.append(node)
                     else:
                         nodes_to_arrange.append(node)

cura/CuraPackageManager.py

@@ -1,19 +1,26 @@
 # Copyright (c) 2018 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
+import glob
+import os
 
+from pathlib import Path
 from typing import Any, cast, Dict, List, Set, Tuple, TYPE_CHECKING, Optional
 
+from UM.Logger import Logger
+from UM.PluginRegistry import PluginRegistry
 from cura.CuraApplication import CuraApplication  # To find some resource types.
 from cura.Settings.GlobalStack import GlobalStack
 
 from UM.PackageManager import PackageManager  # The class we're extending.
 from UM.Resources import Resources  # To find storage paths for some resource types.
 from UM.i18n import i18nCatalog
+from urllib.parse import unquote_plus
+
 catalog = i18nCatalog("cura")
 
 if TYPE_CHECKING:
     from UM.Qt.QtApplication import QtApplication
-    from PyQt5.QtCore import QObject
+    from PyQt6.QtCore import QObject
 
 
 class CuraPackageManager(PackageManager):
@@ -48,9 +55,62 @@ 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)
+
+        # 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
+        # have an `intents` folder. For completeness, we will look in both locations of in the curapackage and map them both to the
+        # `intent` folder.
+        self._installation_dirs_dict["intents"] = Resources.getStoragePath(CuraApplication.ResourceTypes.IntentInstanceContainer)
+        self._installation_dirs_dict["intent"] = Resources.getStoragePath(CuraApplication.ResourceTypes.IntentInstanceContainer)
 
         super().initialize()
 
+    def isMaterialBundled(self, file_name: str, guid: str):
+        """ Check if there is a bundled material name with file_name and guid """
+        for path in Resources.getSecureSearchPaths():
+            # Secure search paths are install directory paths, if a material is in here it must be bundled.
+
+            paths = [Path(p) for p in glob.glob(path + '/**/*.xml.fdm_material', recursive=True)]
+            for material in paths:
+                if material.name == file_name:
+                    Logger.info(f"Found bundled material: {material.name}. Located in path: {str(material)}")
+                    with open(material, encoding="utf-8") as f:
+                        # Make sure the file we found has the same guid as our material
+                        # Parsing this xml would be better but the namespace is needed to search it.
+                        parsed_guid = PluginRegistry.getInstance().getPluginObject(
+                            "XmlMaterialProfile").getMetadataFromSerialized(
+                            f.read(), "GUID")
+                        if guid == parsed_guid:
+                            # The material we found matches both filename and GUID
+                            return True
+
+        return False
+
+    def getMaterialFilePackageId(self, file_name: str, guid: str) -> str:
+        """Get the id of the installed material package that contains file_name"""
+        file_name = unquote_plus(file_name)
+        for material_package in [f for f in os.scandir(self._installation_dirs_dict["materials"]) if f.is_dir()]:
+            package_id = material_package.name
+
+            for root, _, file_names in os.walk(material_package.path):
+                if file_name not in file_names:
+                    # File with the name we are looking for is not in this directory
+                    continue
+
+                with open(os.path.join(root, file_name), encoding="utf-8") as f:
+                    # Make sure the file we found has the same guid as our material
+                    # Parsing this xml would be better but the namespace is needed to search it.
+                    parsed_guid = PluginRegistry.getInstance().getPluginObject("XmlMaterialProfile").getMetadataFromSerialized(
+                        f.read(), "GUID")
+
+                    if guid == parsed_guid:
+                        return package_id
+
+        Logger.error("Could not find package_id for file: {} with GUID: {} ".format(file_name, guid))
+        Logger.error(f"Bundled paths searched: {list(Resources.getSecureSearchPaths())}")
+        return ""
+
     def getMachinesUsingPackage(self, package_id: str) -> Tuple[List[Tuple[GlobalStack, str, str]], List[Tuple[GlobalStack, str, str]]]:
         """Returns a list of where the package is used
 

cura/CuraVersion.py.in

@@ -1,13 +0,0 @@
-# Copyright (c) 2020 Ultimaker B.V.
-# Cura is released under the terms of the LGPLv3 or higher.
-
-CuraAppName = "@CURA_APP_NAME@"
-CuraAppDisplayName = "@CURA_APP_DISPLAY_NAME@"
-CuraVersion = "@CURA_VERSION@"
-CuraBuildType = "@CURA_BUILDTYPE@"
-CuraDebugMode = True if "@_cura_debugmode@" == "ON" else False
-CuraCloudAPIRoot = "@CURA_CLOUD_API_ROOT@"
-CuraCloudAPIVersion = "@CURA_CLOUD_API_VERSION@"
-CuraCloudAccountAPIRoot = "@CURA_CLOUD_ACCOUNT_API_ROOT@"
-CuraMarketplaceRoot = "@CURA_MARKETPLACE_ROOT@"
-CuraDigitalFactoryURL = "@CURA_DIGITAL_FACTORY_URL@"

cura/CuraView.py

@@ -1,7 +1,7 @@
 # Copyright (c) 2018 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
 
-from PyQt5.QtCore import pyqtProperty, QUrl
+from PyQt6.QtCore import pyqtProperty, QUrl
 
 from UM.Resources import Resources
 from UM.View.View import View

cura/LayerPolygon.py

@@ -24,9 +24,12 @@ class LayerPolygon:
     PrimeTowerType = 11
     __number_of_types = 12
 
-    __jump_map = numpy.logical_or(numpy.logical_or(numpy.arange(__number_of_types) == NoneType, numpy.arange(__number_of_types) == MoveCombingType), numpy.arange(__number_of_types) == MoveRetractionType)
+    __jump_map = numpy.logical_or(numpy.logical_or(numpy.arange(__number_of_types) == NoneType,
+                                                   numpy.arange(__number_of_types) == MoveCombingType),
+                                                   numpy.arange(__number_of_types) == MoveRetractionType)
 
-    def __init__(self, extruder: int, line_types: numpy.ndarray, data: numpy.ndarray, line_widths: numpy.ndarray, line_thicknesses: numpy.ndarray, line_feedrates: numpy.ndarray) -> None:
+    def __init__(self, extruder: int, line_types: numpy.ndarray, data: numpy.ndarray,
+                 line_widths: numpy.ndarray, line_thicknesses: numpy.ndarray, line_feedrates: numpy.ndarray) -> None:
         """LayerPolygon, used in ProcessSlicedLayersJob
 
         :param extruder: The position of the extruder
@@ -39,10 +42,12 @@ class LayerPolygon:
 
         self._extruder = extruder
         self._types = line_types
-        for i in range(len(self._types)):
-            if self._types[i] >= self.__number_of_types: # Got faulty line data from the engine.
-                Logger.log("w", "Found an unknown line type: %s", i)
-                self._types[i] = self.NoneType
+        unknown_types = numpy.where(self._types >= self.__number_of_types, self._types, None)
+        if unknown_types.any():
+            # Got faulty line data from the engine.
+            for idx in unknown_types:
+                Logger.warning(f"Found an unknown line type at: {idx}")
+                self._types[idx] = self.NoneType
         self._data = data
         self._line_widths = line_widths
         self._line_thicknesses = line_thicknesses
@@ -58,14 +63,16 @@ class LayerPolygon:
         self._mesh_line_count = len(self._types) - self._jump_count
         self._vertex_count = self._mesh_line_count + numpy.sum(self._types[1:] == self._types[:-1])
 
-        # Buffering the colors shouldn't be necessary as it is not 
+        # Buffering the colors shouldn't be necessary as it is not
         # re-used and can save a lot of memory usage.
         self._color_map = LayerPolygon.getColorMap()
         self._colors = self._color_map[self._types]  # type: numpy.ndarray
 
-        # When type is used as index returns true if type == LayerPolygon.InfillType or type == LayerPolygon.SkinType or type == LayerPolygon.SupportInfillType
+        # When type is used as index returns true if type == LayerPolygon.InfillType
+        # or type == LayerPolygon.SkinType
+        # or type == LayerPolygon.SupportInfillType
         # Should be generated in better way, not hardcoded.
-        self._is_infill_or_skin_type_map = numpy.array([0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0], dtype = bool)
+        self._is_infill_or_skin_type_map = numpy.array([0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0], dtype=bool)
 
         self._build_cache_line_mesh_mask = None  # type: Optional[numpy.ndarray]
         self._build_cache_needed_points = None  # type: Optional[numpy.ndarray]
@@ -80,12 +87,14 @@ class LayerPolygon:
         # Only if the type of line segment changes do we need to add an extra vertex to change colors
         self._build_cache_needed_points[1:, 0][:, numpy.newaxis] = self._types[1:] != self._types[:-1]
         # Mark points as unneeded if they are of types we don't want in the line mesh according to the calculated mask
-        numpy.logical_and(self._build_cache_needed_points, self._build_cache_line_mesh_mask, self._build_cache_needed_points )
+        numpy.logical_and(self._build_cache_needed_points, self._build_cache_line_mesh_mask, self._build_cache_needed_points)
 
         self._vertex_begin = 0
         self._vertex_end = cast(int, numpy.sum(self._build_cache_needed_points))
 
-    def build(self, vertex_offset: int, index_offset: int, vertices: numpy.ndarray, colors: numpy.ndarray, line_dimensions: numpy.ndarray, feedrates: numpy.ndarray, extruders: numpy.ndarray, line_types: numpy.ndarray, indices: numpy.ndarray) -> None:
+    def build(self, vertex_offset: int, index_offset: int, vertices: numpy.ndarray,
+              colors: numpy.ndarray, line_dimensions: numpy.ndarray, feedrates: numpy.ndarray,
+              extruders: numpy.ndarray, line_types: numpy.ndarray, indices: numpy.ndarray) -> None:
         """Set all the arrays provided by the function caller, representing the LayerPolygon
 
         The arrays are either by vertex or by indices.
@@ -111,19 +120,20 @@ class LayerPolygon:
         line_mesh_mask = self._build_cache_line_mesh_mask
         needed_points_list = self._build_cache_needed_points
 
-        # Index to the points we need to represent the line mesh. This is constructed by generating simple
-        # start and end points for each line. For line segment n these are points n and n+1. Row n reads [n n+1] 
-        # Then then the indices for the points we don't need are thrown away based on the pre-calculated list. 
-        index_list = ( numpy.arange(len(self._types)).reshape((-1, 1)) + numpy.array([[0, 1]]) ).reshape((-1, 1))[needed_points_list.reshape((-1, 1))]
+        # Index to the points we need to represent the line mesh.
+        # This is constructed by generating simple start and end points for each line.
+        # For line segment n, these are points n and n+1. Row n reads [n n+1]
+        # Then the indices for the points we don't need are thrown away based on the pre-calculated list.
+        index_list = (numpy.arange(len(self._types)).reshape((-1, 1)) + numpy.array([[0, 1]])).reshape((-1, 1))[needed_points_list.reshape((-1, 1))]
 
         # The relative values of begin and end indices have already been set in buildCache, so we only need to offset them to the parents offset.
         self._vertex_begin += vertex_offset
         self._vertex_end += vertex_offset
 
-        # Points are picked based on the index list to get the vertices needed. 
+        # Points are picked based on the index list to get the vertices needed.
         vertices[self._vertex_begin:self._vertex_end, :] = self._data[index_list, :]
 
-        # Create an array with colors for each vertex and remove the color data for the points that has been thrown away. 
+        # Create an array with colors for each vertex and remove the color data for the points that has been thrown away.
         colors[self._vertex_begin:self._vertex_end, :] = numpy.tile(self._colors, (1, 2)).reshape((-1, 4))[needed_points_list.ravel()]
 
         # Create an array with line widths and thicknesses for each vertex.
@@ -138,14 +148,15 @@ class LayerPolygon:
         # Convert type per vertex to type per line
         line_types[self._vertex_begin:self._vertex_end] = numpy.tile(self._types, (1, 2)).reshape((-1, 1))[needed_points_list.ravel()][:, 0]
 
-        # The relative values of begin and end indices have already been set in buildCache, so we only need to offset them to the parents offset.
+        # The relative values of begin and end indices have already been set in buildCache,
+        # so we only need to offset them to the parents offset.
         self._index_begin += index_offset
         self._index_end += index_offset
 
-        indices[self._index_begin:self._index_end, :] = numpy.arange(self._index_end-self._index_begin, dtype = numpy.int32).reshape((-1, 1))
+        indices[self._index_begin:self._index_end, :] = numpy.arange(self._index_end-self._index_begin, dtype=numpy.int32).reshape((-1, 1))
         # When the line type changes the index needs to be increased by 2.
         indices[self._index_begin:self._index_end, :] += numpy.cumsum(needed_points_list[line_mesh_mask.ravel(), 0], dtype = numpy.int32).reshape((-1, 1))
-        # Each line segment goes from it's starting point p to p+1, offset by the vertex index. 
+        # Each line segment goes from it's starting point p to p+1, offset by the vertex index.
         # The -1 is to compensate for the necessarily True value of needed_points_list[0,0] which causes an unwanted +1 in cumsum above.
         indices[self._index_begin:self._index_end, :] += numpy.array([self._vertex_begin - 1, self._vertex_begin])
 
@@ -214,13 +225,12 @@ class LayerPolygon:
         """
 
         normals = numpy.copy(self._data)
-        normals[:, 1] = 0.0 # We are only interested in 2D normals
+        normals[:, 1] = 0.0  # We are only interested in 2D normals
 
         # Calculate the edges between points.
-        # The call to numpy.roll shifts the entire array by one so that
-        # we end up subtracting each next point from the current, wrapping
-        # around. This gives us the edges from the next point to the current
-        # point.
+        # The call to numpy.roll shifts the entire array by one
+        # so that we end up subtracting each next point from the current, wrapping around.
+        # This gives us the edges from the next point to the current point.
         normals = numpy.diff(normals, 1, 0)
 
         # Calculate the length of each edge using standard Pythagoras
@@ -245,17 +255,17 @@ class LayerPolygon:
         if cls.__color_map is None:
             theme = cast(Theme, QtApplication.getInstance().getTheme())
             cls.__color_map = numpy.array([
-                theme.getColor("layerview_none").getRgbF(), # NoneType
-                theme.getColor("layerview_inset_0").getRgbF(), # Inset0Type
-                theme.getColor("layerview_inset_x").getRgbF(), # InsetXType
-                theme.getColor("layerview_skin").getRgbF(), # SkinType
-                theme.getColor("layerview_support").getRgbF(), # SupportType
-                theme.getColor("layerview_skirt").getRgbF(), # SkirtType
-                theme.getColor("layerview_infill").getRgbF(), # InfillType
-                theme.getColor("layerview_support_infill").getRgbF(), # SupportInfillType
-                theme.getColor("layerview_move_combing").getRgbF(), # MoveCombingType
-                theme.getColor("layerview_move_retraction").getRgbF(), # MoveRetractionType
-                theme.getColor("layerview_support_interface").getRgbF(),  # SupportInterfaceType
+                theme.getColor("layerview_none").getRgbF(),  # NoneType
+                theme.getColor("layerview_inset_0").getRgbF(),  # Inset0Type
+                theme.getColor("layerview_inset_x").getRgbF(),  # InsetXType
+                theme.getColor("layerview_skin").getRgbF(),  # SkinType
+                theme.getColor("layerview_support").getRgbF(),  # SupportType
+                theme.getColor("layerview_skirt").getRgbF(),  # SkirtType
+                theme.getColor("layerview_infill").getRgbF(),  # InfillType
+                theme.getColor("layerview_support_infill").getRgbF(),  # SupportInfillType
+                theme.getColor("layerview_move_combing").getRgbF(),  # MoveCombingType
+                theme.getColor("layerview_move_retraction").getRgbF(),  # MoveRetractionType
+                theme.getColor("layerview_support_interface").getRgbF(),   # SupportInterfaceType
                 theme.getColor("layerview_prime_tower").getRgbF()   # PrimeTowerType
             ])
 

cura/MachineAction.py

@@ -4,7 +4,7 @@
 import os
 from typing import Optional
 
-from PyQt5.QtCore import QObject, QUrl, pyqtSlot, pyqtProperty, pyqtSignal
+from PyQt6.QtCore import QObject, QUrl, pyqtSlot, pyqtProperty, pyqtSignal
 
 from UM.Logger import Logger
 from UM.PluginObject import PluginObject
@@ -33,8 +33,11 @@ class MachineAction(QObject, PluginObject):
         self._qml_url = ""
         self._view = None
         self._finished = False
+        self._open_as_dialog = True
+        self._visible = True
 
     labelChanged = pyqtSignal()
+    visibilityChanged = pyqtSignal()
     onFinished = pyqtSignal()
 
     def getKey(self) -> str:
@@ -79,6 +82,15 @@ class MachineAction(QObject, PluginObject):
 
         pass
 
+    @pyqtSlot()
+    def execute(self) -> None:
+        self._execute()
+    
+    def _execute(self) -> None:
+        """Protected implementation of execute."""
+        
+        pass
+
     @pyqtSlot()
     def setFinished(self) -> None:
         self._finished = True
@@ -94,7 +106,7 @@ class MachineAction(QObject, PluginObject):
 
         plugin_path = PluginRegistry.getInstance().getPluginPath(self.getPluginId())
         if plugin_path is None:
-            Logger.log("e", "Cannot create QML view: cannot find plugin path for plugin [%s]", self.getPluginId())
+            Logger.error(f"Cannot create QML view: cannot find plugin path for plugin {self.getPluginId()}")
             return None
         path = os.path.join(plugin_path, self._qml_url)
 
@@ -106,7 +118,7 @@ class MachineAction(QObject, PluginObject):
     def qmlPath(self) -> "QUrl":
         plugin_path = PluginRegistry.getInstance().getPluginPath(self.getPluginId())
         if plugin_path is None:
-            Logger.log("e", "Cannot create QML view: cannot find plugin path for plugin [%s]", self.getPluginId())
+            Logger.error(f"Cannot create QML view: cannot find plugin path for plugin {self.getPluginId()}")
             return QUrl("")
         path = os.path.join(plugin_path, self._qml_url)
         return QUrl.fromLocalFile(path)
@@ -114,3 +126,30 @@ class MachineAction(QObject, PluginObject):
     @pyqtSlot(result = QObject)
     def getDisplayItem(self) -> Optional["QObject"]:
         return self._createViewFromQML()
+
+    @pyqtProperty(bool, constant=True)
+    def shouldOpenAsDialog(self) -> bool:
+        """Whether this action will show a dialog.
+
+         If not, the action will directly run the function inside execute().
+
+        :return: Defaults to true to be in line with the old behaviour.
+        """
+        return self._open_as_dialog
+    
+    @pyqtSlot()
+    def setVisible(self, visible: bool) -> None:
+        if self._visible != visible:
+            self._visible = visible
+            self.visibilityChanged.emit()
+    
+    @pyqtProperty(bool, notify = visibilityChanged)
+    def visible(self) -> bool:
+        """Whether this action button will be visible.
+
+         Example: Show only when isLoggedIn
+
+        :return: Defaults to true to be in line with the old behaviour.
+        """
+
+        return self._visible

cura/Machines/MachineErrorChecker.py

@@ -5,7 +5,7 @@ import time
 
 from collections import deque
 
-from PyQt5.QtCore import QObject, QTimer, pyqtSignal, pyqtProperty
+from PyQt6.QtCore import QObject, QTimer, pyqtSignal, pyqtProperty
 from typing import Optional, Any, Set
 
 from UM.Logger import Logger
@@ -43,16 +43,14 @@ class MachineErrorChecker(QObject):
         self._application = cura.CuraApplication.CuraApplication.getInstance()
         self._machine_manager = self._application.getMachineManager()
 
-        self._start_time = 0.  # measure checking time
+        self._check_start_time = time.time()
 
-        # This timer delays the starting of error check so we can react less frequently if the user is frequently
-        # changing settings.
-        self._error_check_timer = QTimer(self)
-        self._error_check_timer.setInterval(100)
-        self._error_check_timer.setSingleShot(True)
+        self._setCheckTimer()
 
         self._keys_to_check = set()  # type: Set[str]
 
+        self._num_keys_to_check_per_update = 10
+
     def initialize(self) -> None:
         self._error_check_timer.timeout.connect(self._rescheduleCheck)
 
@@ -64,6 +62,18 @@ class MachineErrorChecker(QObject):
 
         self._onMachineChanged()
 
+    def _setCheckTimer(self) -> None:
+        """A QTimer to regulate error check frequency
+
+        This timer delays the starting of error check
+        so we can react less frequently if the user is frequently
+        changing settings.
+        """
+
+        self._error_check_timer = QTimer(self)
+        self._error_check_timer.setInterval(100)
+        self._error_check_timer.setSingleShot(True)
+
     def _onMachineChanged(self) -> None:
         if self._global_stack:
             self._global_stack.propertyChanged.disconnect(self.startErrorCheckPropertyChanged)
@@ -150,7 +160,7 @@ class MachineErrorChecker(QObject):
                 self._stacks_and_keys_to_check.append((stack, key))
 
         self._application.callLater(self._checkStack)
-        self._start_time = time.time()
+        self._check_start_time = time.time()
         Logger.log("d", "New error check scheduled.")
 
     def _checkStack(self) -> None:
@@ -162,37 +172,37 @@ class MachineErrorChecker(QObject):
 
         self._check_in_progress = True
 
-        # If there is nothing to check any more, it means there is no error.
-        if not self._stacks_and_keys_to_check:
-            # Finish
-            self._setResult(False)
-            return
+        for i in range(self._num_keys_to_check_per_update):
+            # If there is nothing to check any more, it means there is no error.
+            if not self._stacks_and_keys_to_check:
+                # Finish
+                self._setResult(False)
+                return
 
-        # Get the next stack and key to check
-        stack, key = self._stacks_and_keys_to_check.popleft()
+            # Get the next stack and key to check
+            stack, key = self._stacks_and_keys_to_check.popleft()
 
-        enabled = stack.getProperty(key, "enabled")
-        if not enabled:
-            self._application.callLater(self._checkStack)
-            return
+            enabled = stack.getProperty(key, "enabled")
+            if not enabled:
+                continue
 
-        validation_state = stack.getProperty(key, "validationState")
-        if validation_state is None:
-            # Setting is not validated. This can happen if there is only a setting definition.
-            # We do need to validate it, because a setting definitions value can be set by a function, which could
-            # be an invalid setting.
-            definition = stack.getSettingDefinition(key)
-            validator_type = SettingDefinition.getValidatorForType(definition.type)
-            if validator_type:
-                validator = validator_type(key)
-                validation_state = validator(stack)
-        if validation_state in (ValidatorState.Exception, ValidatorState.MaximumError, ValidatorState.MinimumError, ValidatorState.Invalid):
-            # Since we don't know if any of the settings we didn't check is has an error value, store the list for the
-            # next check.
-            keys_to_recheck = {setting_key for stack, setting_key in self._stacks_and_keys_to_check}
-            keys_to_recheck.add(key)
-            self._setResult(True, keys_to_recheck = keys_to_recheck)
-            return
+            validation_state = stack.getProperty(key, "validationState")
+            if validation_state is None:
+                # Setting is not validated. This can happen if there is only a setting definition.
+                # We do need to validate it, because a setting definitions value can be set by a function, which could
+                # be an invalid setting.
+                definition = stack.getSettingDefinition(key)
+                validator_type = SettingDefinition.getValidatorForType(definition.type)
+                if validator_type:
+                    validator = validator_type(key)
+                    validation_state = validator(stack)
+            if validation_state in (ValidatorState.Exception, ValidatorState.MaximumError, ValidatorState.MinimumError, ValidatorState.Invalid):
+                # Since we don't know if any of the settings we didn't check is has an error value, store the list for the
+                # next check.
+                keys_to_recheck = {setting_key for stack, setting_key in self._stacks_and_keys_to_check}
+                keys_to_recheck.add(key)
+                self._setResult(True, keys_to_recheck = keys_to_recheck)
+                return
 
         # Schedule the check for the next key
         self._application.callLater(self._checkStack)
@@ -202,12 +212,10 @@ class MachineErrorChecker(QObject):
             self._has_errors = result
             self.hasErrorUpdated.emit()
             self._machine_manager.stacksValidationChanged.emit()
-        if keys_to_recheck is None:
-            self._keys_to_check = set()
-        else:
-            self._keys_to_check = keys_to_recheck
+        self._keys_to_check = keys_to_recheck if keys_to_recheck else set()
         self._need_to_check = False
         self._check_in_progress = False
         self.needToWaitForResultChanged.emit()
         self.errorCheckFinished.emit()
-        Logger.log("i", "Error check finished, result = %s, time = %0.1fs", result, time.time() - self._start_time)
+        execution_time = time.time() - self._check_start_time
+        Logger.info(f"Error check finished, result = {result}, time = {execution_time:.2f}s")

cura/Machines/MachineNode.py

@@ -129,7 +129,7 @@ class MachineNode(ContainerNode):
             if name not in groups_by_name:
                 # CURA-6599
                 # For some reason, QML will get null or fail to convert type for MachineManager.activeQualityChangesGroup() to
-                # a QObject. Setting the object ownership to QQmlEngine.CppOwnership doesn't work, but setting the object
+                # a QObject. Setting the object ownership to QQmlEngine.ObjectOwnership.CppOwnership doesn't work, but setting the object
                 # parent to application seems to work.
                 from cura.CuraApplication import CuraApplication
                 groups_by_name[name] = QualityChangesGroup(name, quality_type = quality_changes["quality_type"],

cura/Machines/Models/ActiveIntentQualitiesModel.py

@@ -0,0 +1,131 @@
+# Copyright (c) 2022 Ultimaker B.V.
+# Cura is released under the terms of the LGPLv3 or higher.
+from typing import Optional, Set, Dict, List, Any
+
+from PyQt6.QtCore import Qt, QObject, QTimer
+
+import cura.CuraApplication
+from UM.Logger import Logger
+from UM.Qt.ListModel import ListModel
+from UM.Settings.ContainerStack import ContainerStack
+from cura.Machines.ContainerTree import ContainerTree
+from cura.Machines.Models.MachineModelUtils import fetchLayerHeight
+from cura.Machines.MaterialNode import MaterialNode
+from cura.Machines.QualityGroup import QualityGroup
+from cura.Settings.IntentManager import IntentManager
+
+
+class ActiveIntentQualitiesModel(ListModel):
+    NameRole = Qt.ItemDataRole.UserRole + 1
+    DisplayTextRole = Qt.ItemDataRole.UserRole + 2
+    QualityTypeRole = Qt.ItemDataRole.UserRole + 3
+    LayerHeightRole = Qt.ItemDataRole.UserRole + 4
+    IntentCategeoryRole = Qt.ItemDataRole.UserRole + 5
+
+    def __init__(self, parent: Optional[QObject] = None) -> None:
+        super().__init__(parent)
+
+        self.addRoleName(self.NameRole, "name")
+        self.addRoleName(self.QualityTypeRole, "quality_type")
+        self.addRoleName(self.LayerHeightRole, "layer_height")
+        self.addRoleName(self.DisplayTextRole, "display_text")
+        self.addRoleName(self.IntentCategeoryRole, "intent_category")
+
+        self._intent_category = ""
+
+        IntentManager.intentCategoryChangedSignal.connect(self._update)
+        machine_manager = cura.CuraApplication.CuraApplication.getInstance().getMachineManager()
+        machine_manager.activeQualityGroupChanged.connect(self._update)
+        machine_manager.globalContainerChanged.connect(self._updateDelayed)
+        machine_manager.extruderChanged.connect(self._updateDelayed)  # We also need to update if an extruder gets disabled
+
+        self._update_timer = QTimer()
+        self._update_timer.setInterval(100)
+        self._update_timer.setSingleShot(True)
+        self._update_timer.timeout.connect(self._update)
+
+        self._update()
+
+    def _updateDelayed(self):
+        self._update_timer.start()
+
+    def _onChanged(self, container: ContainerStack) -> None:
+        if container.getMetaDataEntry("type") == "intent":
+            self._updateDelayed()
+
+    def _update(self):
+        active_extruder_stack = cura.CuraApplication.CuraApplication.getInstance().getMachineManager().activeStack
+        if active_extruder_stack:
+            self._intent_category = active_extruder_stack.intent.getMetaDataEntry("intent_category", "")
+
+        new_items: List[Dict[str, Any]] = []
+        global_stack = cura.CuraApplication.CuraApplication.getInstance().getGlobalContainerStack()
+        if not global_stack:
+            self.setItems(new_items)
+            return
+        quality_groups = ContainerTree.getInstance().getCurrentQualityGroups()
+
+        material_nodes = self._getActiveMaterials()
+
+        added_quality_type_set: Set[str] = set()
+        for material_node in material_nodes:
+            intents = self._getIntentsForMaterial(material_node, quality_groups)
+            for intent in intents:
+                if intent["quality_type"] not in added_quality_type_set:
+                    new_items.append(intent)
+                    added_quality_type_set.add(intent["quality_type"])
+
+        new_items = sorted(new_items, key=lambda x: x["layer_height"])
+        self.setItems(new_items)
+
+    def _getActiveMaterials(self) -> Set["MaterialNode"]:
+        """Get the active materials for all extruders. No duplicates will be returned"""
+
+        global_stack = cura.CuraApplication.CuraApplication.getInstance().getGlobalContainerStack()
+        if global_stack is None:
+            return set()
+
+        container_tree = ContainerTree.getInstance()
+        machine_node = container_tree.machines[global_stack.definition.getId()]
+        nodes: Set[MaterialNode] = set()
+
+        for extruder in global_stack.extruderList:
+            active_variant_name = extruder.variant.getMetaDataEntry("name")
+            if active_variant_name not in machine_node.variants:
+                Logger.log("w", "Could not find the variant %s", active_variant_name)
+                continue
+            active_variant_node = machine_node.variants[active_variant_name]
+            active_material_node = active_variant_node.materials.get(extruder.material.getMetaDataEntry("base_file"))
+            if active_material_node is None:
+                Logger.log("w", "Could not find the material %s", extruder.material.getMetaDataEntry("base_file"))
+                continue
+            nodes.add(active_material_node)
+
+        return nodes
+
+    def _getIntentsForMaterial(self, active_material_node: "MaterialNode", quality_groups: Dict[str, "QualityGroup"]) -> List[Dict[str, Any]]:
+        extruder_intents: List[Dict[str, Any]] = []
+
+        for quality_id, quality_node in active_material_node.qualities.items():
+            if quality_node.quality_type not in quality_groups:  # Don't add the empty quality type (or anything else that would crash, defensively).
+                continue
+            quality_group = quality_groups[quality_node.quality_type]
+
+            if not quality_group.is_available:
+                continue
+
+            layer_height = fetchLayerHeight(quality_group)
+
+            for intent_id, intent_node in quality_node.intents.items():
+                if intent_node.intent_category != self._intent_category:
+                    continue
+
+                extruder_intents.append({"name": quality_group.name,
+                                         "display_text": f"<b>{quality_group.name}</b> - {layer_height}mm",
+                                         "quality_type": quality_group.quality_type,
+                                         "layer_height": layer_height,
+                                         "intent_category": self._intent_category
+                                         })
+        return extruder_intents
+
+

cura/Machines/Models/BaseMaterialsModel.py

@@ -3,7 +3,7 @@
 
 from typing import Dict, Set
 
-from PyQt5.QtCore import Qt, QTimer, pyqtSignal, pyqtProperty
+from PyQt6.QtCore import Qt, QTimer, pyqtSignal, pyqtProperty
 
 from UM.Qt.ListModel import ListModel
 from UM.Logger import Logger
@@ -61,22 +61,22 @@ class BaseMaterialsModel(ListModel):
         ContainerTree.getInstance().materialsChanged.connect(self._materialsListChanged)
         self._application.getMaterialManagementModel().favoritesChanged.connect(self._onChanged)
 
-        self.addRoleName(Qt.UserRole + 1, "root_material_id")
-        self.addRoleName(Qt.UserRole + 2, "id")
-        self.addRoleName(Qt.UserRole + 3, "GUID")
-        self.addRoleName(Qt.UserRole + 4, "name")
-        self.addRoleName(Qt.UserRole + 5, "brand")
-        self.addRoleName(Qt.UserRole + 6, "description")
-        self.addRoleName(Qt.UserRole + 7, "material")
-        self.addRoleName(Qt.UserRole + 8, "color_name")
-        self.addRoleName(Qt.UserRole + 9, "color_code")
-        self.addRoleName(Qt.UserRole + 10, "density")
-        self.addRoleName(Qt.UserRole + 11, "diameter")
-        self.addRoleName(Qt.UserRole + 12, "approximate_diameter")
-        self.addRoleName(Qt.UserRole + 13, "adhesion_info")
-        self.addRoleName(Qt.UserRole + 14, "is_read_only")
-        self.addRoleName(Qt.UserRole + 15, "container_node")
-        self.addRoleName(Qt.UserRole + 16, "is_favorite")
+        self.addRoleName(Qt.ItemDataRole.UserRole + 1, "root_material_id")
+        self.addRoleName(Qt.ItemDataRole.UserRole + 2, "id")
+        self.addRoleName(Qt.ItemDataRole.UserRole + 3, "GUID")
+        self.addRoleName(Qt.ItemDataRole.UserRole + 4, "name")
+        self.addRoleName(Qt.ItemDataRole.UserRole + 5, "brand")
+        self.addRoleName(Qt.ItemDataRole.UserRole + 6, "description")
+        self.addRoleName(Qt.ItemDataRole.UserRole + 7, "material")
+        self.addRoleName(Qt.ItemDataRole.UserRole + 8, "color_name")
+        self.addRoleName(Qt.ItemDataRole.UserRole + 9, "color_code")
+        self.addRoleName(Qt.ItemDataRole.UserRole + 10, "density")
+        self.addRoleName(Qt.ItemDataRole.UserRole + 11, "diameter")
+        self.addRoleName(Qt.ItemDataRole.UserRole + 12, "approximate_diameter")
+        self.addRoleName(Qt.ItemDataRole.UserRole + 13, "adhesion_info")
+        self.addRoleName(Qt.ItemDataRole.UserRole + 14, "is_read_only")
+        self.addRoleName(Qt.ItemDataRole.UserRole + 15, "container_node")
+        self.addRoleName(Qt.ItemDataRole.UserRole + 16, "is_favorite")
 
     def _onChanged(self) -> None:
         self._update_timer.start()

cura/Machines/Models/BuildPlateModel.py

@@ -1,14 +1,14 @@
 # Copyright (c) 2019 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
 
-from PyQt5.QtCore import Qt
+from PyQt6.QtCore import Qt
 from UM.Logger import Logger
 from UM.Qt.ListModel import ListModel
 
 
 class BuildPlateModel(ListModel):
-    NameRole = Qt.UserRole + 1
-    ContainerNodeRole = Qt.UserRole + 2
+    NameRole = Qt.ItemDataRole.UserRole + 1
+    ContainerNodeRole = Qt.ItemDataRole.UserRole + 2
 
     def __init__(self, parent = None):
         super().__init__(parent)

cura/Machines/Models/CompatibleMachineModel.py

@@ -0,0 +1,81 @@
+# Copyright (c) 2022 Ultimaker B.V.
+# Cura is released under the terms of the LGPLv3 or higher.
+
+from typing import Optional
+
+from PyQt6.QtCore import Qt, QObject, pyqtSlot, pyqtProperty, pyqtSignal
+
+from UM.Logger import Logger
+from UM.Qt.ListModel import ListModel
+from UM.i18n import i18nCatalog
+
+
+class CompatibleMachineModel(ListModel):
+    NameRole = Qt.ItemDataRole.UserRole + 1
+    UniqueIdRole = Qt.ItemDataRole.UserRole + 2
+    ExtrudersRole = Qt.ItemDataRole.UserRole + 3
+
+    def __init__(self, parent: Optional[QObject] = None) -> None:
+        super().__init__(parent)
+
+        self._catalog = i18nCatalog("cura")
+
+        self.addRoleName(self.NameRole, "name")
+        self.addRoleName(self.UniqueIdRole, "unique_id")
+        self.addRoleName(self.ExtrudersRole, "extruders")
+
+        self._update()
+
+        from cura.CuraApplication import CuraApplication
+        machine_manager = CuraApplication.getInstance().getMachineManager()
+        machine_manager.globalContainerChanged.connect(self._update)
+        machine_manager.outputDevicesChanged.connect(self._update)
+
+    @pyqtSlot()
+    def forceUpdate(self):
+        self._update()
+
+    def _update(self) -> None:
+        self.clear()
+
+        def _makeMaterial(brand, name, color):
+            if name.lower() in ["", "empty"]:
+                return {"brand": "", "name": "(empty)", "hexcolor": "#ffffff"}
+            else:
+                return {"brand": brand, "name": name, "hexcolor": color}
+
+        from cura.CuraApplication import CuraApplication
+        machine_manager = CuraApplication.getInstance().getMachineManager()
+
+        # Loop over the output-devices, not the stacks; need all applicable configurations, not just the current loaded one.
+        for output_device in machine_manager.printerOutputDevices:
+            for printer in output_device.printers:
+                extruder_configs = dict()
+
+                # initialize & add current active material:
+                for extruder in printer.extruders:
+                    materials = [_makeMaterial(
+                        extruder.activeMaterial.brand, extruder.activeMaterial.name, extruder.activeMaterial.color)]
+                    extruder_configs[extruder.getPosition()] = {
+                        "position": extruder.getPosition(),
+                        "core": extruder.hotendID,
+                        "materials": materials
+                    }
+
+                # add currently inactive, but possible materials:
+                for configuration in printer.availableConfigurations:
+                    for extruder in configuration.extruderConfigurations:
+                        if not extruder.position in extruder_configs:
+                            Logger.log("w", f"No active extruder for position {extruder.position}.")
+                            continue
+
+                        entry = _makeMaterial(extruder.material.brand, extruder.material.name, extruder.material.color)
+                        if entry not in extruder_configs[extruder.position]["materials"]:
+                            extruder_configs[extruder.position]["materials"].append(entry)
+
+                if any([len(extruder["materials"]) > 0 for extruder in extruder_configs.values()]):
+                    self.appendItem({
+                        "name": printer.name,
+                        "unique_id": printer.name,  # <- Can assume the cloud doesn't have duplicate names?
+                        "extruders": list(extruder_configs.values())
+                    })

cura/Machines/Models/CustomQualityProfilesDropDownMenuModel.py

@@ -10,7 +10,7 @@ from cura.Machines.ContainerTree import ContainerTree
 from cura.Machines.Models.QualityProfilesDropDownMenuModel import QualityProfilesDropDownMenuModel
 
 if TYPE_CHECKING:
-    from PyQt5.QtCore import QObject
+    from PyQt6.QtCore import QObject
     from UM.Settings.Interfaces import ContainerInterface
 
 

cura/Machines/Models/DiscoveredCloudPrintersModel.py

@@ -1,6 +1,6 @@
 from typing import Optional, TYPE_CHECKING, List, Dict
 
-from PyQt5.QtCore import QObject, pyqtSlot, Qt, pyqtSignal, pyqtProperty
+from PyQt6.QtCore import QObject, pyqtSlot, Qt, pyqtSignal, pyqtProperty
 
 from UM.Qt.ListModel import ListModel
 
@@ -12,10 +12,10 @@ class DiscoveredCloudPrintersModel(ListModel):
     """Model used to inform the application about newly added cloud printers, which are discovered from the user's
      account """
 
-    DeviceKeyRole = Qt.UserRole + 1
-    DeviceNameRole = Qt.UserRole + 2
-    DeviceTypeRole = Qt.UserRole + 3
-    DeviceFirmwareVersionRole = Qt.UserRole + 4
+    DeviceKeyRole = Qt.ItemDataRole.UserRole + 1
+    DeviceNameRole = Qt.ItemDataRole.UserRole + 2
+    DeviceTypeRole = Qt.ItemDataRole.UserRole + 3
+    DeviceFirmwareVersionRole = Qt.ItemDataRole.UserRole + 4
 
     cloudPrintersDetectedChanged = pyqtSignal(bool)
 

cura/Machines/Models/DiscoveredPrintersModel.py

@@ -3,7 +3,7 @@
 
 from typing import Callable, Dict, List, Optional, TYPE_CHECKING
 
-from PyQt5.QtCore import pyqtSlot, pyqtProperty, pyqtSignal, QObject, QTimer
+from PyQt6.QtCore import pyqtSlot, pyqtProperty, pyqtSignal, QObject, QTimer
 
 from UM.i18n import i18nCatalog
 from UM.Logger import Logger

cura/Machines/Models/ExtrudersModel.py

@@ -1,7 +1,7 @@
 # Copyright (c) 2018 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
 
-from PyQt5.QtCore import Qt, pyqtSignal, pyqtProperty, QTimer
+from PyQt6.QtCore import Qt, pyqtSignal, pyqtProperty, QTimer
 from typing import Iterable, TYPE_CHECKING
 
 from UM.i18n import i18nCatalog
@@ -23,43 +23,43 @@ class ExtrudersModel(ListModel):
     """
 
     # The ID of the container stack for the extruder.
-    IdRole = Qt.UserRole + 1
+    IdRole = Qt.ItemDataRole.UserRole + 1
 
-    NameRole = Qt.UserRole + 2
+    NameRole = Qt.ItemDataRole.UserRole + 2
     """Human-readable name of the extruder."""
 
-    ColorRole = Qt.UserRole + 3
+    ColorRole = Qt.ItemDataRole.UserRole + 3
     """Colour of the material loaded in the extruder."""
 
-    IndexRole = Qt.UserRole + 4
+    IndexRole = Qt.ItemDataRole.UserRole + 4
     """Index of the extruder, which is also the value of the setting itself.
 
     An index of 0 indicates the first extruder, an index of 1 the second one, and so on. This is the value that will 
     be saved in instance containers. """
 
     # The ID of the definition of the extruder.
-    DefinitionRole = Qt.UserRole + 5
+    DefinitionRole = Qt.ItemDataRole.UserRole + 5
 
     # The material of the extruder.
-    MaterialRole = Qt.UserRole + 6
+    MaterialRole = Qt.ItemDataRole.UserRole + 6
 
     # The variant of the extruder.
-    VariantRole = Qt.UserRole + 7
-    StackRole = Qt.UserRole + 8
+    VariantRole = Qt.ItemDataRole.UserRole + 7
+    StackRole = Qt.ItemDataRole.UserRole + 8
 
-    MaterialBrandRole = Qt.UserRole + 9
-    ColorNameRole = Qt.UserRole + 10
+    MaterialBrandRole = Qt.ItemDataRole.UserRole + 9
+    ColorNameRole = Qt.ItemDataRole.UserRole + 10
 
-    EnabledRole = Qt.UserRole + 11
+    EnabledRole = Qt.ItemDataRole.UserRole + 11
     """Is the extruder enabled?"""
 
-    MaterialTypeRole = Qt.UserRole + 12
+    MaterialTypeRole = Qt.ItemDataRole.UserRole + 12
     """The type of the material (e.g. PLA, ABS, PETG, etc.)."""
 
     defaultColors = ["#ffc924", "#86ec21", "#22eeee", "#245bff", "#9124ff", "#ff24c8"]
     """List of colours to display if there is no material or the material has no known colour. """
 
-    MaterialNameRole = Qt.UserRole + 13
+    MaterialNameRole = Qt.ItemDataRole.UserRole + 13
 
     def __init__(self, parent = None):
         """Initialises the extruders model, defining the roles and listening for changes in the data.

cura/Machines/Models/FirstStartMachineActionsModel.py

@@ -3,7 +3,7 @@
 
 from typing import Optional, Dict, Any, TYPE_CHECKING
 
-from PyQt5.QtCore import QObject, Qt, pyqtProperty, pyqtSignal, pyqtSlot
+from PyQt6.QtCore import QObject, Qt, pyqtProperty, pyqtSignal, pyqtSlot
 
 from UM.Qt.ListModel import ListModel
 
@@ -19,9 +19,9 @@ class FirstStartMachineActionsModel(ListModel):
         - action  : the MachineAction object itself
     """
 
-    TitleRole = Qt.UserRole + 1
-    ContentRole = Qt.UserRole + 2
-    ActionRole = Qt.UserRole + 3
+    TitleRole = Qt.ItemDataRole.UserRole + 1
+    ContentRole = Qt.ItemDataRole.UserRole + 2
+    ActionRole = Qt.ItemDataRole.UserRole + 3
 
     def __init__(self, application: "CuraApplication", parent: Optional[QObject] = None) -> None:
         super().__init__(parent)

cura/Machines/Models/GlobalStacksModel.py

@@ -1,7 +1,7 @@
 # Copyright (c) 2021 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
 
-from PyQt5.QtCore import Qt, QTimer, pyqtProperty, pyqtSignal
+from PyQt6.QtCore import Qt, QTimer, pyqtProperty, pyqtSignal
 from typing import List, Optional
 
 from UM.Qt.ListModel import ListModel
@@ -15,14 +15,14 @@ from cura.UltimakerCloud.UltimakerCloudConstants import META_CAPABILITIES  # To
 
 
 class GlobalStacksModel(ListModel):
-    NameRole = Qt.UserRole + 1
-    IdRole = Qt.UserRole + 2
-    HasRemoteConnectionRole = Qt.UserRole + 3
-    ConnectionTypeRole = Qt.UserRole + 4
-    MetaDataRole = Qt.UserRole + 5
-    DiscoverySourceRole = Qt.UserRole + 6  # For separating local and remote printers in the machine management page
-    RemovalWarningRole = Qt.UserRole + 7
-    IsOnlineRole = Qt.UserRole + 8
+    NameRole = Qt.ItemDataRole.UserRole + 1
+    IdRole = Qt.ItemDataRole.UserRole + 2
+    HasRemoteConnectionRole = Qt.ItemDataRole.UserRole + 3
+    ConnectionTypeRole = Qt.ItemDataRole.UserRole + 4
+    MetaDataRole = Qt.ItemDataRole.UserRole + 5
+    DiscoverySourceRole = Qt.ItemDataRole.UserRole + 6  # For separating local and remote printers in the machine management page
+    RemovalWarningRole = Qt.ItemDataRole.UserRole + 7
+    IsOnlineRole = Qt.ItemDataRole.UserRole + 8
 
     def __init__(self, parent = None) -> None:
         super().__init__(parent)
@@ -44,6 +44,7 @@ class GlobalStacksModel(ListModel):
         self._filter_connection_type = None  # type: Optional[ConnectionType]
         self._filter_online_only = False
         self._filter_capabilities: List[str] = []  # Required capabilities that all listed printers must have.
+        self._filter_abstract_machines: Optional[bool] = None
 
         # Listen to changes
         CuraContainerRegistry.getInstance().containerAdded.connect(self._onContainerChanged)
@@ -54,6 +55,7 @@ class GlobalStacksModel(ListModel):
     filterConnectionTypeChanged = pyqtSignal()
     filterCapabilitiesChanged = pyqtSignal()
     filterOnlineOnlyChanged = pyqtSignal()
+    filterAbstractMachinesChanged = pyqtSignal()
 
     def setFilterConnectionType(self, new_filter: Optional[ConnectionType]) -> None:
         if self._filter_connection_type != new_filter:
@@ -98,6 +100,22 @@ class GlobalStacksModel(ListModel):
         """
         return self._filter_capabilities
 
+    def setFilterAbstractMachines(self, new_filter: Optional[bool]) -> None:
+        if self._filter_abstract_machines != new_filter:
+            self._filter_abstract_machines = new_filter
+            self.filterAbstractMachinesChanged.emit()
+
+    @pyqtProperty(bool, fset = setFilterAbstractMachines, notify = filterAbstractMachinesChanged)
+    def filterAbstractMachines(self) -> Optional[bool]:
+        """
+        Weather we include abstract printers, non-abstract printers or both
+
+        if this is set to None both abstract and non-abstract printers will be included in the list
+                   set to True will only include abstract printers
+                   set to False will only inclde non-abstract printers
+        """
+        return self._filter_abstract_machines
+
     def _onContainerChanged(self, container) -> None:
         """Handler for container added/removed events from registry"""
 
@@ -130,12 +148,16 @@ class GlobalStacksModel(ListModel):
             if self._filter_online_only and not is_online:
                 continue
 
+            is_abstract_machine = parseBool(container_stack.getMetaDataEntry("is_abstract_machine", False))
+            if self._filter_abstract_machines is not None and self._filter_abstract_machines is not is_abstract_machine:
+                continue
+
             capabilities = set(container_stack.getMetaDataEntry(META_CAPABILITIES, "").split(","))
             if set(self._filter_capabilities) - capabilities:  # Not all required capabilities are met.
                 continue
 
             device_name = container_stack.getMetaDataEntry("group_name", container_stack.getName())
-            section_name = "Connected printers" if has_remote_connection else "Preset printers"
+            section_name = self._catalog.i18nc("@label", "Connected printers") if has_remote_connection else self._catalog.i18nc("@label", "Preset printers")
             section_name = self._catalog.i18nc("@info:title", section_name)
 
             default_removal_warning = self._catalog.i18nc(

cura/Machines/Models/IntentCategoryModel.py

@@ -2,14 +2,14 @@
 #Cura is released under the terms of the LGPLv3 or higher.
 
 import collections
-from PyQt5.QtCore import Qt, QTimer
+from PyQt6.QtCore import Qt, QTimer
 from typing import TYPE_CHECKING, Optional, Dict
 
 from cura.Machines.Models.IntentModel import IntentModel
 from cura.Settings.IntentManager import IntentManager
 from UM.Qt.ListModel import ListModel
 from UM.Settings.ContainerRegistry import ContainerRegistry #To update the list if anything changes.
-from PyQt5.QtCore import pyqtSignal
+from PyQt6.QtCore import pyqtSignal
 import cura.CuraApplication
 if TYPE_CHECKING:
     from UM.Settings.ContainerRegistry import ContainerInterface
@@ -21,11 +21,11 @@ catalog = i18nCatalog("cura")
 class IntentCategoryModel(ListModel):
     """Lists the intent categories that are available for the current printer configuration. """
 
-    NameRole = Qt.UserRole + 1
-    IntentCategoryRole = Qt.UserRole + 2
-    WeightRole = Qt.UserRole + 3
-    QualitiesRole = Qt.UserRole + 4
-    DescriptionRole = Qt.UserRole + 5
+    NameRole = Qt.ItemDataRole.UserRole + 1
+    IntentCategoryRole = Qt.ItemDataRole.UserRole + 2
+    WeightRole = Qt.ItemDataRole.UserRole + 3
+    QualitiesRole = Qt.ItemDataRole.UserRole + 4
+    DescriptionRole = Qt.ItemDataRole.UserRole + 5
 
     modelUpdated = pyqtSignal()
 
@@ -111,7 +111,7 @@ class IntentCategoryModel(ListModel):
             except ValueError:
                 weight = 99
             result.append({
-                "name": IntentCategoryModel.translation(category, "name", category),
+                "name": IntentCategoryModel.translation(category, "name", category.title()),
                 "description": IntentCategoryModel.translation(category, "description", None),
                 "intent_category": category,
                 "weight": weight,

cura/Machines/Models/IntentModel.py

@@ -2,7 +2,7 @@
 # Cura is released under the terms of the LGPLv3 or higher.
 from typing import Optional, Dict, Any, Set, List
 
-from PyQt5.QtCore import Qt, QObject, pyqtProperty, pyqtSignal, QTimer
+from PyQt6.QtCore import Qt, QObject, pyqtProperty, pyqtSignal, QTimer
 
 import cura.CuraApplication
 from UM.Qt.ListModel import ListModel
@@ -15,11 +15,11 @@ from cura.Machines.QualityGroup import QualityGroup
 
 
 class IntentModel(ListModel):
-    NameRole = Qt.UserRole + 1
-    QualityTypeRole = Qt.UserRole + 2
-    LayerHeightRole = Qt.UserRole + 3
-    AvailableRole = Qt.UserRole + 4
-    IntentRole = Qt.UserRole + 5
+    NameRole = Qt.ItemDataRole.UserRole + 1
+    QualityTypeRole = Qt.ItemDataRole.UserRole + 2
+    LayerHeightRole = Qt.ItemDataRole.UserRole + 3
+    AvailableRole = Qt.ItemDataRole.UserRole + 4
+    IntentRole = Qt.ItemDataRole.UserRole + 5
 
     def __init__(self, parent: Optional[QObject] = None) -> None:
         super().__init__(parent)

cura/Machines/Models/IntentSelectionModel.py

@@ -0,0 +1,129 @@
+# Copyright (c) 2022 Ultimaker B.V.
+# Cura is released under the terms of the LGPLv3 or higher.
+
+import collections
+from typing import OrderedDict, Optional
+
+from PyQt6.QtCore import Qt, QTimer, QObject
+
+import cura
+from UM import i18nCatalog
+from UM.Logger import Logger
+from UM.Qt.ListModel import ListModel
+from UM.Settings.ContainerRegistry import ContainerRegistry
+from UM.Settings.Interfaces import ContainerInterface
+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
+
+    def __init__(self, parent: Optional[QObject] = None) -> None:
+        super().__init__(parent)
+
+        self.addRoleName(self.NameRole, "name")
+        self.addRoleName(self.IntentCategoryRole, "intent_category")
+        self.addRoleName(self.WeightRole, "weight")
+        self.addRoleName(self.DescriptionRole, "description")
+        self.addRoleName(self.IconRole, "icon")
+
+        application = cura.CuraApplication.CuraApplication.getInstance()
+
+        ContainerRegistry.getInstance().containerAdded.connect(self._onContainerChange)
+        ContainerRegistry.getInstance().containerRemoved.connect(self._onContainerChange)
+        machine_manager = cura.CuraApplication.CuraApplication.getInstance().getMachineManager()
+        machine_manager.activeMaterialChanged.connect(self._update)
+        machine_manager.activeVariantChanged.connect(self._update)
+        machine_manager.extruderChanged.connect(self._update)
+
+        extruder_manager = application.getExtruderManager()
+        extruder_manager.extrudersChanged.connect(self._update)
+
+        self._update_timer: QTimer = QTimer()
+        self._update_timer.setInterval(100)
+        self._update_timer.setSingleShot(True)
+        self._update_timer.timeout.connect(self._update)
+
+        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
+
+    def _onContainerChange(self, container: ContainerInterface) -> None:
+        """Updates the list of intents if an intent profile was added or removed."""
+
+        if container.getMetaDataEntry("type") == "intent":
+            self._update()
+
+    def _onChange(self) -> None:
+        self._update_timer.start()
+
+    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()
+        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():
+            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, {})
+
+            try:
+                weight = list(default_profile_info.keys()).index(category)
+            except ValueError:
+                weight = len(available_categories) + i
+
+            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,
+            })
+
+        result.sort(key=lambda k: k["weight"])
+
+        self.setItems(result)
+
+

cura/Machines/Models/MachineListModel.py

@@ -0,0 +1,159 @@
+# Copyright (c) 2022 Ultimaker B.V.
+# Cura is released under the terms of the LGPLv3 or higher.
+
+# The MachineListModel is used to display the connected printers in the interface. Both the abstract machines and all
+# online cloud connected printers are represented within this ListModel. Additional information such as the number of
+# connected printers for each printer type is gathered.
+
+from typing import Optional, List, cast
+
+from PyQt6.QtCore import Qt, QTimer, QObject, pyqtSlot, pyqtProperty, pyqtSignal
+
+from UM.Qt.ListModel import ListModel
+from UM.Settings.ContainerStack import ContainerStack
+from UM.Settings.Interfaces import ContainerInterface
+from UM.i18n import i18nCatalog
+from UM.Util import parseBool
+
+from cura.Settings.CuraContainerRegistry import CuraContainerRegistry
+from cura.Settings.GlobalStack import GlobalStack
+
+
+class MachineListModel(ListModel):
+    NameRole = Qt.ItemDataRole.UserRole + 1
+    IdRole = Qt.ItemDataRole.UserRole + 2
+    HasRemoteConnectionRole = Qt.ItemDataRole.UserRole + 3
+    MetaDataRole = Qt.ItemDataRole.UserRole + 4
+    IsOnlineRole = Qt.ItemDataRole.UserRole + 5
+    MachineCountRole = Qt.ItemDataRole.UserRole + 6
+    IsAbstractMachineRole = Qt.ItemDataRole.UserRole + 7
+    ComponentTypeRole = Qt.ItemDataRole.UserRole + 8
+    IsNetworkedMachineRole = Qt.ItemDataRole.UserRole + 9
+
+    def __init__(self, parent: Optional[QObject] = None, machines_filter: List[GlobalStack] = None, listenToChanges: bool = True) -> None:
+        super().__init__(parent)
+
+        self._show_cloud_printers = False
+        self._machines_filter = machines_filter
+
+        self._catalog = i18nCatalog("cura")
+
+        self.addRoleName(self.NameRole, "name")
+        self.addRoleName(self.IdRole, "id")
+        self.addRoleName(self.HasRemoteConnectionRole, "hasRemoteConnection")
+        self.addRoleName(self.MetaDataRole, "metadata")
+        self.addRoleName(self.IsOnlineRole, "isOnline")
+        self.addRoleName(self.MachineCountRole, "machineCount")
+        self.addRoleName(self.IsAbstractMachineRole, "isAbstractMachine")
+        self.addRoleName(self.ComponentTypeRole, "componentType")
+        self.addRoleName(self.IsNetworkedMachineRole, "isNetworked")
+
+        self._change_timer = QTimer()
+        self._change_timer.setInterval(200)
+        self._change_timer.setSingleShot(True)
+        self._change_timer.timeout.connect(self._update)
+
+        if listenToChanges:
+            CuraContainerRegistry.getInstance().containerAdded.connect(self._onContainerChanged)
+            CuraContainerRegistry.getInstance().containerMetaDataChanged.connect(self._onContainerChanged)
+            CuraContainerRegistry.getInstance().containerRemoved.connect(self._onContainerChanged)
+            self._updateDelayed()
+
+    showCloudPrintersChanged = pyqtSignal(bool)
+
+    @pyqtProperty(bool, notify=showCloudPrintersChanged)
+    def showCloudPrinters(self) -> bool:
+        return self._show_cloud_printers
+
+    @pyqtSlot(bool) 
+    def setShowCloudPrinters(self, show_cloud_printers: bool) -> None:
+        self._show_cloud_printers = show_cloud_printers
+        self._updateDelayed()
+        self.showCloudPrintersChanged.emit(show_cloud_printers)
+
+    def _onContainerChanged(self, container: ContainerInterface) -> None:
+        """Handler for container added/removed events from registry"""
+
+        # We only need to update when the added / removed container GlobalStack
+        if isinstance(container, GlobalStack):
+            self._updateDelayed()
+
+    def _updateDelayed(self) -> None:
+        self._change_timer.start()
+
+    def _getMachineStacks(self) -> List[ContainerStack]:
+        return CuraContainerRegistry.getInstance().findContainerStacks(type = "machine")
+
+    def _getAbstractMachineStacks(self) -> List[ContainerStack]:
+        return CuraContainerRegistry.getInstance().findContainerStacks(is_abstract_machine = "True")
+
+    def set_machines_filter(self, machines_filter: Optional[List[GlobalStack]]) -> None:
+        self._machines_filter = machines_filter
+        self._update()
+
+    def _update(self) -> None:
+        self.clear()
+
+        from cura.CuraApplication import CuraApplication
+        machines_manager = CuraApplication.getInstance().getMachineManager()
+
+        other_machine_stacks = self._getMachineStacks()
+        other_machine_stacks.sort(key = lambda machine: machine.getName().upper())
+
+        abstract_machine_stacks = self._getAbstractMachineStacks()
+        abstract_machine_stacks.sort(key = lambda machine: machine.getName().upper(), reverse = True)
+
+        if self._machines_filter is not None:
+            filter_ids = [machine_filter.id for machine_filter in self._machines_filter]
+            other_machine_stacks = [machine for machine in other_machine_stacks if machine.id in filter_ids]
+            abstract_machine_stacks = [machine for machine in abstract_machine_stacks if machine.id in filter_ids]
+
+        for abstract_machine in abstract_machine_stacks:
+            definition_id = abstract_machine.definition.getId()
+            online_machine_stacks = machines_manager.getMachinesWithDefinition(definition_id, online_only = True)
+
+            online_machine_stacks = list(filter(lambda machine: machine.hasNetworkedConnection(), online_machine_stacks))
+            online_machine_stacks.sort(key=lambda machine: machine.getName().upper())
+
+            other_machine_stacks.remove(abstract_machine)
+            if abstract_machine in online_machine_stacks:
+                online_machine_stacks.remove(abstract_machine)
+
+            # Create a list item for abstract machine
+            self.addItem(abstract_machine, True, len(online_machine_stacks))
+
+            # Create list of machines that are children of the abstract machine
+            for stack in online_machine_stacks:
+                if self._show_cloud_printers:
+                    self.addItem(stack, True)
+                # Remove this machine from the other stack list
+                if stack in other_machine_stacks:
+                    other_machine_stacks.remove(stack)
+
+        if len(abstract_machine_stacks) > 0:
+            self.appendItem({
+                "componentType": "HIDE_BUTTON" if self._show_cloud_printers else "SHOW_BUTTON",
+                "isOnline": True,
+                "isAbstractMachine": False,
+                "machineCount": 0,
+                "catergory": "connected",
+            })
+
+        for stack in other_machine_stacks:
+            self.addItem(stack, False)
+
+    def addItem(self, container_stack: ContainerStack, is_online: bool, machine_count: int = 0) -> None:
+        if parseBool(container_stack.getMetaDataEntry("hidden", False)):
+            return
+
+        self.appendItem({
+            "componentType": "MACHINE",
+            "name": container_stack.getName(),
+            "id": container_stack.getId(),
+            "metadata": container_stack.getMetaData().copy(),
+            "isOnline": is_online,
+            "isAbstractMachine": parseBool(container_stack.getMetaDataEntry("is_abstract_machine", False)),
+            "isNetworked": cast(GlobalStack, container_stack).hasNetworkedConnection() if isinstance(container_stack, GlobalStack) else False,
+            "machineCount": machine_count,
+            "catergory": "connected" if is_online else "other",
+        })

cura/Machines/Models/MaterialBrandsModel.py

@@ -1,7 +1,9 @@
 # Copyright (c) 2019 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
 
-from PyQt5.QtCore import Qt, pyqtSignal
+from PyQt6.QtCore import Qt, pyqtSignal
+from PyQt6.QtQml import QQmlEngine
+
 from UM.Qt.ListModel import ListModel
 from cura.Machines.Models.BaseMaterialsModel import BaseMaterialsModel
 
@@ -9,10 +11,11 @@ class MaterialTypesModel(ListModel):
 
     def __init__(self, parent = None):
         super().__init__(parent)
+        QQmlEngine.setObjectOwnership(self, QQmlEngine.ObjectOwnership.CppOwnership)
 
-        self.addRoleName(Qt.UserRole + 1, "name")
-        self.addRoleName(Qt.UserRole + 2, "brand")
-        self.addRoleName(Qt.UserRole + 3, "colors")
+        self.addRoleName(Qt.ItemDataRole.UserRole + 1, "name")
+        self.addRoleName(Qt.ItemDataRole.UserRole + 2, "brand")
+        self.addRoleName(Qt.ItemDataRole.UserRole + 3, "colors")
 
 class MaterialBrandsModel(BaseMaterialsModel):
 
@@ -20,9 +23,10 @@ class MaterialBrandsModel(BaseMaterialsModel):
 
     def __init__(self, parent = None):
         super().__init__(parent)
+        QQmlEngine.setObjectOwnership(self, QQmlEngine.ObjectOwnership.CppOwnership)
 
-        self.addRoleName(Qt.UserRole + 1, "name")
-        self.addRoleName(Qt.UserRole + 2, "material_types")
+        self.addRoleName(Qt.ItemDataRole.UserRole + 1, "name")
+        self.addRoleName(Qt.ItemDataRole.UserRole + 2, "material_types")
 
         self._update()
 
@@ -74,16 +78,15 @@ class MaterialBrandsModel(BaseMaterialsModel):
             material_type_item_list = []
             brand_item = {
                 "name": brand,
-                "material_types": MaterialTypesModel(self)
+                "material_types": MaterialTypesModel()
             }
 
             for material_type, material_list in material_dict.items():
                 material_type_item = {
                     "name": material_type,
                     "brand": brand,
-                    "colors": BaseMaterialsModel(self)
+                    "colors": BaseMaterialsModel()
                 }
-                material_type_item["colors"].clear()
 
                 # Sort materials by name
                 material_list = sorted(material_list, key = lambda x: x["name"].upper())

cura/Machines/Models/MaterialManagementModel.py

@@ -2,8 +2,8 @@
 # Cura is released under the terms of the LGPLv3 or higher.
 
 import copy  # To duplicate materials.
-from PyQt5.QtCore import pyqtSignal, pyqtSlot, QObject, QUrl
-from PyQt5.QtGui import QDesktopServices
+from PyQt6.QtCore import pyqtSignal, pyqtSlot, QObject, QUrl
+from PyQt6.QtGui import QDesktopServices
 from typing import Any, Dict, Optional, TYPE_CHECKING
 import uuid  # To generate new GUIDs for new materials.
 
@@ -34,62 +34,6 @@ class MaterialManagementModel(QObject):
     def __init__(self, parent: Optional[QObject] = None) -> None:
         super().__init__(parent = parent)
         self._material_sync = CloudMaterialSync(parent=self)
-        self._checkIfNewMaterialsWereInstalled()
-
-    def _checkIfNewMaterialsWereInstalled(self) -> None:
-        """
-        Checks whether new material packages were installed in the latest startup. If there were, then it shows
-        a message prompting the user to sync the materials with their printers.
-        """
-        application = cura.CuraApplication.CuraApplication.getInstance()
-        for package_id, package_data in application.getPackageManager().getPackagesInstalledOnStartup().items():
-            if package_data["package_info"]["package_type"] == "material":
-                # At least one new material was installed
-                # TODO: This should be enabled again once CURA-8609 is merged
-                #self._showSyncNewMaterialsMessage()
-                break
-
-    def _showSyncNewMaterialsMessage(self) -> None:
-        sync_materials_message = Message(
-                text = catalog.i18nc("@action:button",
-                                     "Please sync the material profiles with your printers before starting to print."),
-                title = catalog.i18nc("@action:button", "New materials installed"),
-                message_type = Message.MessageType.WARNING,
-                lifetime = 0
-        )
-
-        sync_materials_message.addAction(
-                "sync",
-                name = catalog.i18nc("@action:button", "Sync materials"),
-                icon = "",
-                description = "Sync your newly installed materials with your printers.",
-                button_align = Message.ActionButtonAlignment.ALIGN_RIGHT
-        )
-
-        sync_materials_message.addAction(
-                "learn_more",
-                name = catalog.i18nc("@action:button", "Learn more"),
-                icon = "",
-                description = "Learn more about syncing your newly installed materials with your printers.",
-                button_align = Message.ActionButtonAlignment.ALIGN_LEFT,
-                button_style = Message.ActionButtonStyle.LINK
-        )
-        sync_materials_message.actionTriggered.connect(self._onSyncMaterialsMessageActionTriggered)
-
-        # Show the message only if there are printers that support material export
-        container_registry = cura.CuraApplication.CuraApplication.getInstance().getContainerRegistry()
-        global_stacks = container_registry.findContainerStacks(type = "machine")
-        if any([stack.supportsMaterialExport for stack in global_stacks]):
-            sync_materials_message.show()
-
-    def _onSyncMaterialsMessageActionTriggered(self, sync_message: Message, sync_message_action: str):
-        if sync_message_action == "sync":
-            QDesktopServices.openUrl(QUrl("https://example.com/openSyncAllWindow"))
-            # self.openSyncAllWindow()
-            sync_message.hide()
-        elif sync_message_action == "learn_more":
-            QDesktopServices.openUrl(QUrl("https://support.ultimaker.com/hc/en-us/articles/360013137919?utm_source=cura&utm_medium=software&utm_campaign=sync-material-printer-message"))
-
 
     @pyqtSlot("QVariant", result = bool)
     def canMaterialBeRemoved(self, material_node: "MaterialNode") -> bool:

cura/Machines/Models/MultiBuildPlateModel.py

@@ -1,7 +1,7 @@
 # Copyright (c) 2018 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
 
-from PyQt5.QtCore import QTimer, pyqtSignal, pyqtProperty
+from PyQt6.QtCore import QTimer, pyqtSignal, pyqtProperty
 
 from UM.Application import Application
 from UM.Scene.Camera import Camera

cura/Machines/Models/NozzleModel.py

@@ -1,7 +1,7 @@
 # Copyright (c) 2019 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
 
-from PyQt5.QtCore import Qt
+from PyQt6.QtCore import Qt
 
 from UM.Logger import Logger
 from UM.Qt.ListModel import ListModel
@@ -10,9 +10,9 @@ from cura.Machines.ContainerTree import ContainerTree
 
 
 class NozzleModel(ListModel):
-    IdRole = Qt.UserRole + 1
-    HotendNameRole = Qt.UserRole + 2
-    ContainerNodeRole = Qt.UserRole + 3
+    IdRole = Qt.ItemDataRole.UserRole + 1
+    HotendNameRole = Qt.ItemDataRole.UserRole + 2
+    ContainerNodeRole = Qt.ItemDataRole.UserRole + 3
 
     def __init__(self, parent = None):
         super().__init__(parent)

cura/Machines/Models/QualityManagementModel.py

@@ -2,7 +2,7 @@
 # Cura is released under the terms of the LGPLv3 or higher.
 
 from typing import Any, cast, Dict, Optional, TYPE_CHECKING
-from PyQt5.QtCore import pyqtSlot, QObject, Qt, QTimer
+from PyQt6.QtCore import pyqtSlot, QObject, Qt, QTimer
 
 from UM.Logger import Logger
 from UM.Qt.ListModel import ListModel
@@ -29,13 +29,13 @@ if TYPE_CHECKING:
 class QualityManagementModel(ListModel):
     """This the QML model for the quality management page."""
 
-    NameRole = Qt.UserRole + 1
-    IsReadOnlyRole = Qt.UserRole + 2
-    QualityGroupRole = Qt.UserRole + 3
-    QualityTypeRole = Qt.UserRole + 4
-    QualityChangesGroupRole = Qt.UserRole + 5
-    IntentCategoryRole = Qt.UserRole + 6
-    SectionNameRole = Qt.UserRole + 7
+    NameRole = Qt.ItemDataRole.UserRole + 1
+    IsReadOnlyRole = Qt.ItemDataRole.UserRole + 2
+    QualityGroupRole = Qt.ItemDataRole.UserRole + 3
+    QualityTypeRole = Qt.ItemDataRole.UserRole + 4
+    QualityChangesGroupRole = Qt.ItemDataRole.UserRole + 5
+    IntentCategoryRole = Qt.ItemDataRole.UserRole + 6
+    SectionNameRole = Qt.ItemDataRole.UserRole + 7
 
     def __init__(self, parent: Optional["QObject"] = None) -> None:
         super().__init__(parent)
@@ -184,7 +184,8 @@ class QualityManagementModel(ListModel):
                 container_registry.addContainer(container.duplicate(new_id, new_name))
 
     @pyqtSlot(str)
-    def createQualityChanges(self, base_name: str) -> None:
+    @pyqtSlot(str, bool)
+    def createQualityChanges(self, base_name: str, activate_after_success: bool = False) -> None:
         """Create quality changes containers from the user containers in the active stacks.
 
         This will go through the global and extruder stacks and create quality_changes containers from the user
@@ -233,6 +234,14 @@ class QualityManagementModel(ListModel):
 
             container_registry.addContainer(new_changes)
 
+        if activate_after_success:
+            # At this point, the QualityChangesGroup object for the new changes may not exist yet.
+            # This can be forced by asking for all of them. At that point it's just as well to loop.
+            for quality_changes in ContainerTree.getInstance().getCurrentQualityChangesGroups():
+                if quality_changes.name == unique_name:
+                    machine_manager.setQualityChangesGroup(quality_changes)
+                    break
+
     def _createQualityChanges(self, quality_type: str, intent_category: Optional[str], new_name: str, machine: "GlobalStack", extruder_stack: Optional["ExtruderStack"]) -> "InstanceContainer":
         """Create a quality changes container with the given set-up.
 
@@ -358,8 +367,9 @@ class QualityManagementModel(ListModel):
                 "quality_type": quality_type,
                 "quality_changes_group": None,
                 "intent_category": intent_category,
-                "section_name": catalog.i18nc("@label", intent_translations.get(intent_category, {}).get("name", catalog.i18nc("@label", "Unknown"))),
+                "section_name": catalog.i18nc("@label", intent_translations.get(intent_category, {}).get("name", catalog.i18nc("@label", intent_category.title()))),
             })
+
         # Sort by quality_type for each intent category
         intent_translations_list = list(intent_translations)
 

cura/Machines/Models/QualityProfilesDropDownMenuModel.py

@@ -1,7 +1,7 @@
 # Copyright (c) 2019 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
 
-from PyQt5.QtCore import Qt, QTimer
+from PyQt6.QtCore import Qt, QTimer
 
 import cura.CuraApplication  # Imported this way to prevent circular dependencies.
 from UM.Logger import Logger
@@ -13,14 +13,14 @@ from cura.Machines.Models.MachineModelUtils import fetchLayerHeight
 class QualityProfilesDropDownMenuModel(ListModel):
     """QML Model for all built-in quality profiles. This model is used for the drop-down quality menu."""
 
-    NameRole = Qt.UserRole + 1
-    QualityTypeRole = Qt.UserRole + 2
-    LayerHeightRole = Qt.UserRole + 3
-    LayerHeightUnitRole = Qt.UserRole + 4
-    AvailableRole = Qt.UserRole + 5
-    QualityGroupRole = Qt.UserRole + 6
-    QualityChangesGroupRole = Qt.UserRole + 7
-    IsExperimentalRole = Qt.UserRole + 8
+    NameRole = Qt.ItemDataRole.UserRole + 1
+    QualityTypeRole = Qt.ItemDataRole.UserRole + 2
+    LayerHeightRole = Qt.ItemDataRole.UserRole + 3
+    LayerHeightUnitRole = Qt.ItemDataRole.UserRole + 4
+    AvailableRole = Qt.ItemDataRole.UserRole + 5
+    QualityGroupRole = Qt.ItemDataRole.UserRole + 6
+    QualityChangesGroupRole = Qt.ItemDataRole.UserRole + 7
+    IsExperimentalRole = Qt.ItemDataRole.UserRole + 8
 
     def __init__(self, parent = None):
         super().__init__(parent)

cura/Machines/Models/QualitySettingsModel.py

@@ -1,7 +1,7 @@
 # Copyright (c) 2022 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
 
-from PyQt5.QtCore import pyqtProperty, pyqtSignal, Qt
+from PyQt6.QtCore import pyqtProperty, pyqtSignal, Qt
 from typing import Set
 
 import cura.CuraApplication
@@ -17,13 +17,13 @@ import os
 class QualitySettingsModel(ListModel):
     """This model is used to show details settings of the selected quality in the quality management page."""
 
-    KeyRole = Qt.UserRole + 1
-    LabelRole = Qt.UserRole + 2
-    UnitRole = Qt.UserRole + 3
-    ProfileValueRole = Qt.UserRole + 4
-    ProfileValueSourceRole = Qt.UserRole + 5
-    UserValueRole = Qt.UserRole + 6
-    CategoryRole = Qt.UserRole + 7
+    KeyRole = Qt.ItemDataRole.UserRole + 1
+    LabelRole = Qt.ItemDataRole.UserRole + 2
+    UnitRole = Qt.ItemDataRole.UserRole + 3
+    ProfileValueRole = Qt.ItemDataRole.UserRole + 4
+    ProfileValueSourceRole = Qt.ItemDataRole.UserRole + 5
+    UserValueRole = Qt.ItemDataRole.UserRole + 6
+    CategoryRole = Qt.ItemDataRole.UserRole + 7
 
     GLOBAL_STACK_POSITION = -1
 

cura/Machines/Models/SettingVisibilityPresetsModel.py

@@ -3,7 +3,7 @@
 
 from typing import Optional, List
 
-from PyQt5.QtCore import pyqtProperty, pyqtSignal, pyqtSlot, QObject
+from PyQt6.QtCore import pyqtProperty, pyqtSignal, pyqtSlot, QObject
 
 from UM.Logger import Logger
 from UM.Preferences import Preferences

cura/Machines/Models/UserChangesModel.py

@@ -4,7 +4,7 @@
 import os
 from collections import OrderedDict
 
-from PyQt5.QtCore import pyqtSlot, Qt
+from PyQt6.QtCore import pyqtSlot, Qt
 
 from UM.Application import Application
 from UM.Logger import Logger
@@ -15,12 +15,12 @@ from UM.Qt.ListModel import ListModel
 
 
 class UserChangesModel(ListModel):
-    KeyRole = Qt.UserRole + 1
-    LabelRole = Qt.UserRole + 2
-    ExtruderRole = Qt.UserRole + 3
-    OriginalValueRole = Qt.UserRole + 4
-    UserValueRole = Qt.UserRole + 6
-    CategoryRole = Qt.UserRole + 7
+    KeyRole = Qt.ItemDataRole.UserRole + 1
+    LabelRole = Qt.ItemDataRole.UserRole + 2
+    ExtruderRole = Qt.ItemDataRole.UserRole + 3
+    OriginalValueRole = Qt.ItemDataRole.UserRole + 4
+    UserValueRole = Qt.ItemDataRole.UserRole + 6
+    CategoryRole = Qt.ItemDataRole.UserRole + 7
 
     def __init__(self, parent = None):
         super().__init__(parent = parent)

cura/Machines/QualityChangesGroup.py

@@ -3,7 +3,7 @@
 
 from typing import Any, Dict, Optional
 
-from PyQt5.QtCore import QObject, pyqtProperty, pyqtSignal
+from PyQt6.QtCore import QObject, pyqtProperty, pyqtSignal
 
 
 class QualityChangesGroup(QObject):

cura/OAuth2/AuthorizationHelpers.py

@@ -4,7 +4,7 @@
 from base64 import b64encode
 from datetime import datetime
 from hashlib import sha512
-from PyQt5.QtNetwork import QNetworkReply
+from PyQt6.QtNetwork import QNetworkReply
 import secrets
 from typing import Callable, Optional
 import urllib.parse

cura/OAuth2/AuthorizationService.py

@@ -6,8 +6,8 @@ from datetime import datetime, timedelta
 from typing import Callable, Dict, Optional, TYPE_CHECKING, Union
 from urllib.parse import urlencode, quote_plus
 
-from PyQt5.QtCore import QUrl
-from PyQt5.QtGui import QDesktopServices
+from PyQt6.QtCore import QUrl
+from PyQt6.QtGui import QDesktopServices
 
 from UM.Logger import Logger
 from UM.Message import Message
@@ -274,7 +274,7 @@ class AuthorizationService:
                             self._unable_to_get_data_message.show()
                         else:
                             self._unable_to_get_data_message = Message(i18n_catalog.i18nc("@info",
-                                                                                          "Unable to reach the Ultimaker account server."),
+                                                                                          "Unable to reach the UltiMaker account server."),
                                                                        title = i18n_catalog.i18nc("@info:title", "Log-in failed"),
                                                                        message_type = Message.MessageType.ERROR)
                             Logger.warning("Unable to get user profile using auth data from preferences.")

cura/PlatformPhysics.py

@@ -1,7 +1,7 @@
-# Copyright (c) 2021 Ultimaker B.V.
+# Copyright (c) 2022 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
 
-from PyQt5.QtCore import QTimer
+from PyQt6.QtCore import QTimer
 
 from UM.Application import Application
 from UM.Logger import Logger
@@ -50,8 +50,13 @@ class PlatformPhysics:
         if not self._enabled:
             return
 
+        app_instance = Application.getInstance()
+        app_preferences = app_instance.getPreferences()
+        app_automatic_drop_down = app_preferences.getValue("physics/automatic_drop_down")
+        app_automatic_push_free = app_preferences.getValue("physics/automatic_push_free")
+
         root = self._controller.getScene().getRoot()
-        build_volume = Application.getInstance().getBuildVolume()
+        build_volume = app_instance.getBuildVolume()
         build_volume.updateNodeBoundaryCheck()
 
         # Keep a list of nodes that are moving. We use this so that we don't move two intersecting objects in the
@@ -75,7 +80,7 @@ class PlatformPhysics:
             # Move it downwards if bottom is above platform
             move_vector = Vector()
 
-            if Application.getInstance().getPreferences().getValue("physics/automatic_drop_down") and not (node.getParent() and node.getParent().callDecoration("isGroup") or node.getParent() != root) and node.isEnabled(): #If an object is grouped, don't move it down
+            if node.getSetting(SceneNodeSettings.AutoDropDown, app_automatic_drop_down) and not (node.getParent() and node.getParent().callDecoration("isGroup") or node.getParent() != root) and node.isEnabled(): #If an object is grouped, don't move it down
                 z_offset = node.callDecoration("getZOffset") if node.getDecorator(ZOffsetDecorator.ZOffsetDecorator) else 0
                 move_vector = move_vector.set(y = -bbox.bottom + z_offset)
 
@@ -84,7 +89,7 @@ class PlatformPhysics:
                 node.addDecorator(ConvexHullDecorator())
 
             # only push away objects if this node is a printing mesh
-            if not node.callDecoration("isNonPrintingMesh") and Application.getInstance().getPreferences().getValue("physics/automatic_push_free"):
+            if not node.callDecoration("isNonPrintingMesh") and app_automatic_push_free:
                 # Do not move locked nodes
                 if node.getSetting(SceneNodeSettings.LockPosition):
                     continue

cura/PrintJobPreviewImageProvider.py

@@ -1,6 +1,6 @@
-from PyQt5.QtGui import QImage
-from PyQt5.QtQuick import QQuickImageProvider
-from PyQt5.QtCore import QSize
+from PyQt6.QtGui import QImage
+from PyQt6.QtQuick import QQuickImageProvider
+from PyQt6.QtCore import QSize
 
 from UM.Application import Application
 from typing import Tuple
@@ -8,7 +8,7 @@ from typing import Tuple
 
 class PrintJobPreviewImageProvider(QQuickImageProvider):
     def __init__(self):
-        super().__init__(QQuickImageProvider.Image)
+        super().__init__(QQuickImageProvider.ImageType.Image)
 
     def requestImage(self, id: str, size: QSize) -> Tuple[QImage, QSize]:
         """Request a new image.

cura/PrinterOutput/FirmwareUpdater.py

@@ -1,7 +1,7 @@
 # Copyright (c) 2018 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
 
-from PyQt5.QtCore import QObject, QUrl, pyqtSignal, pyqtProperty
+from PyQt6.QtCore import QObject, QUrl, pyqtSignal, pyqtProperty
 
 from enum import IntEnum
 from threading import Thread

cura/PrinterOutput/GenericOutputController.py

@@ -3,7 +3,7 @@
 
 from typing import TYPE_CHECKING, Set, Union, Optional
 
-from PyQt5.QtCore import QTimer
+from PyQt6.QtCore import QTimer
 
 from .PrinterOutputController import PrinterOutputController
 

cura/PrinterOutput/Models/ExtruderConfigurationModel.py

@@ -2,7 +2,7 @@
 # Cura is released under the terms of the LGPLv3 or higher.
 from typing import Optional
 
-from PyQt5.QtCore import pyqtProperty, QObject, pyqtSignal
+from PyQt6.QtCore import pyqtProperty, QObject, pyqtSignal
 
 from .MaterialOutputModel import MaterialOutputModel
 
@@ -13,9 +13,9 @@ class ExtruderConfigurationModel(QObject):
 
     def __init__(self, position: int = -1) -> None:
         super().__init__()
-        self._position = position  # type: int
-        self._material = None  # type: Optional[MaterialOutputModel]
-        self._hotend_id = None  # type: Optional[str]
+        self._position: int = position
+        self._material: Optional[MaterialOutputModel] = None
+        self._hotend_id: Optional[str] = None
 
     def setPosition(self, position: int) -> None:
         self._position = position

cura/PrinterOutput/Models/ExtruderOutputModel.py

@@ -3,7 +3,7 @@
 
 from typing import Optional, TYPE_CHECKING
 
-from PyQt5.QtCore import pyqtSignal, pyqtProperty, QObject, pyqtSlot
+from PyQt6.QtCore import pyqtSignal, pyqtProperty, QObject, pyqtSlot
 
 from .ExtruderConfigurationModel import ExtruderConfigurationModel
 

cura/PrinterOutput/Models/MaterialOutputModel.py

@@ -3,7 +3,7 @@
 
 from typing import Optional
 
-from PyQt5.QtCore import pyqtProperty, QObject
+from PyQt6.QtCore import pyqtProperty, QObject
 
 
 class MaterialOutputModel(QObject):