Merge remote-tracking branch 'Ultimaker/master' into Felix_Profile

.gitignore

@@ -15,6 +15,7 @@ LC_MESSAGES
 .cache
 *.qmlc
 .mypy_cache
+.pytest_cache
 
 #MacOS
 .DS_Store
@@ -25,6 +26,7 @@ LC_MESSAGES
 *.lprof
 *~
 *.qm
+.directory
 .idea
 cura.desktop
 
@@ -40,7 +42,6 @@ plugins/cura-siemensnx-plugin
 plugins/CuraBlenderPlugin
 plugins/CuraCloudPlugin
 plugins/CuraDrivePlugin
-plugins/CuraDrive
 plugins/CuraLiveScriptingPlugin
 plugins/CuraOpenSCADPlugin
 plugins/CuraPrintProfileCreator

CMakeLists.txt

@@ -17,6 +17,8 @@ if(CURA_DEBUGMODE)
     set(_cura_debugmode "ON")
 endif()
 
+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_SDK_VERSION "" CACHE STRING "SDK version of Cura")

Jenkinsfile

@@ -1,8 +1,11 @@
-parallel_nodes(['linux && cura', 'windows && cura']) {
-    timeout(time: 2, unit: "HOURS") {
+parallel_nodes(['linux && cura', 'windows && cura'])
+{
+    timeout(time: 2, unit: "HOURS")
+    {
 
         // Prepare building
-        stage('Prepare') {
+        stage('Prepare')
+        {
             // Ensure we start with a clean build directory.
             step([$class: 'WsCleanup'])
 
@@ -11,13 +14,17 @@ parallel_nodes(['linux && cura', 'windows && cura']) {
         }
 
         // If any error occurs during building, we want to catch it and continue with the "finale" stage.
-        catchError {
+        catchError
+        {
             // Building and testing should happen in a subdirectory.
-            dir('build') {
+            dir('build')
+            {
                 // Perform the "build". Since Uranium is Python code, this basically only ensures CMake is setup.
-                stage('Build') {
+                stage('Build')
+                {
                     def branch = env.BRANCH_NAME
-                    if(!fileExists("${env.CURA_ENVIRONMENT_PATH}/${branch}")) {
+                    if(!fileExists("${env.CURA_ENVIRONMENT_PATH}/${branch}"))
+                    {
                         branch = "master"
                     }
 
@@ -27,18 +34,37 @@ parallel_nodes(['linux && cura', 'windows && cura']) {
                 }
 
                 // Try and run the unit tests. If this stage fails, we consider the build to be "unstable".
-                stage('Unit Test') {
-                    try {
-                        make('test')
-                    } catch(e) {
-                        currentBuild.result = "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') {
+        stage('Finalize')
+        {
             // Publish the test results to Jenkins.
             junit allowEmptyResults: true, testResults: 'build/junit*.xml'
 

README.md

@@ -20,8 +20,9 @@ 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
+* [python-zeroconf](https://github.com/jstasiak/python-zeroconf) Only required to detect mDNS-enabled printers.
 
 Build scripts
 -------------

cmake/CuraTests.cmake

@@ -6,6 +6,8 @@ include(CMakeParseArguments)
 
 find_package(PythonInterp 3.5.0 REQUIRED)
 
+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})
@@ -34,7 +36,7 @@ function(cura_add_test)
     if (NOT ${test_exists})
         add_test(
             NAME ${_NAME}
-            COMMAND ${PYTHON_EXECUTABLE} -m pytest --junitxml=${CMAKE_BINARY_DIR}/junit-${_NAME}.xml ${_DIRECTORY}
+            COMMAND ${PYTHON_EXECUTABLE} -m pytest --verbose --full-trace --capture=no --no-print-log --junitxml=${CMAKE_BINARY_DIR}/junit-${_NAME}.xml ${_DIRECTORY}
         )
         set_tests_properties(${_NAME} PROPERTIES ENVIRONMENT LANG=C)
         set_tests_properties(${_NAME} PROPERTIES ENVIRONMENT "PYTHONPATH=${_PYTHONPATH}")
@@ -57,5 +59,13 @@ endforeach()
 #Add code style test.
 add_test(
     NAME "code-style"
-    COMMAND ${PYTHON_EXECUTABLE} run_mypy.py WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+    COMMAND ${PYTHON_EXECUTABLE} run_mypy.py
+    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+)
+
+#Add test for whether the shortcut alt-keys are unique in every translation.
+add_test(
+    NAME "shortcut-keys"
+    COMMAND ${PYTHON_EXECUTABLE} scripts/check_shortcut_keys.py
+    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
 )

cura.desktop.in

@@ -13,6 +13,6 @@ TryExec=@CMAKE_INSTALL_FULL_BINDIR@/cura
 Icon=cura-icon
 Terminal=false
 Type=Application
-MimeType=application/sla;application/vnd.ms-3mfdocument;application/prs.wavefront-obj;image/bmp;image/gif;image/jpeg;image/png;model/x3d+xml;
+MimeType=model/stl;application/vnd.ms-3mfdocument;application/prs.wavefront-obj;image/bmp;image/gif;image/jpeg;image/png;model/x3d+xml;text/x-gcode;
 Categories=Graphics;
 Keywords=3D;Printing;Slicer;

cura.sharedmimeinfo

@@ -6,7 +6,7 @@
         <glob-deleteall/>
         <glob pattern="*.3mf"/>
     </mime-type>
-    <mime-type type="application/sla">
+    <mime-type type="model/stl">
         <comment>Computer-aided design and manufacturing format</comment>
         <icon name="unknown"/>
         <glob-deleteall/>
@@ -19,4 +19,12 @@
         <glob-deleteall/>
         <glob pattern="*.obj"/>
     </mime-type>
+    <mime-type type="text/x-gcode">
+        <sub-class-of type="text/plain"/>
+        <comment>Gcode file</comment>
+        <icon name="unknown"/>
+        <glob-deleteall/>
+        <glob pattern="*.gcode"/>
+        <glob pattern="*.g"/>
+    </mime-type>
 </mime-info>

cura/API/Account.py

@@ -0,0 +1,126 @@
+# Copyright (c) 2018 Ultimaker B.V.
+# Cura is released under the terms of the LGPLv3 or higher.
+from typing import Optional, Dict, TYPE_CHECKING
+
+from PyQt5.QtCore import QObject, pyqtSignal, pyqtSlot, pyqtProperty
+
+from UM.i18n import i18nCatalog
+from UM.Message import Message
+from cura import UltimakerCloudAuthentication
+
+from cura.OAuth2.AuthorizationService import AuthorizationService
+from cura.OAuth2.Models import OAuth2Settings
+
+if TYPE_CHECKING:
+    from cura.CuraApplication import CuraApplication
+
+i18n_catalog = i18nCatalog("cura")
+
+
+##  The account API provides a version-proof bridge to use Ultimaker Accounts
+#
+#   Usage:
+#       ``from cura.API import CuraAPI
+#       api = CuraAPI()
+#       api.account.login()
+#       api.account.logout()
+#       api.account.userProfile # Who is logged in``
+#
+class Account(QObject):
+    # Signal emitted when user logged in or out.
+    loginStateChanged = pyqtSignal(bool)
+
+    def __init__(self, application: "CuraApplication", parent = None) -> None:
+        super().__init__(parent)
+        self._application = application
+
+        self._error_message = None  # type: Optional[Message]
+        self._logged_in = False
+
+        self._callback_port = 32118
+        self._oauth_root = UltimakerCloudAuthentication.CuraCloudAccountAPIRoot
+
+        self._oauth_settings = OAuth2Settings(
+            OAUTH_SERVER_URL= self._oauth_root,
+            CALLBACK_PORT=self._callback_port,
+            CALLBACK_URL="http://localhost:{}/callback".format(self._callback_port),
+            CLIENT_ID="um----------------------------ultimaker_cura",
+            CLIENT_SCOPES="account.user.read drive.backup.read drive.backup.write packages.download "
+                          "packages.rating.read packages.rating.write connect.cluster.read connect.cluster.write "
+                          "cura.printjob.read cura.printjob.write cura.mesh.read cura.mesh.write",
+            AUTH_DATA_PREFERENCE_KEY="general/ultimaker_auth_data",
+            AUTH_SUCCESS_REDIRECT="{}/app/auth-success".format(self._oauth_root),
+            AUTH_FAILED_REDIRECT="{}/app/auth-error".format(self._oauth_root)
+        )
+
+        self._authorization_service = AuthorizationService(self._oauth_settings)
+
+    def initialize(self) -> None:
+        self._authorization_service.initialize(self._application.getPreferences())
+        self._authorization_service.onAuthStateChanged.connect(self._onLoginStateChanged)
+        self._authorization_service.onAuthenticationError.connect(self._onLoginStateChanged)
+        self._authorization_service.loadAuthDataFromPreferences()
+
+    ## Returns a boolean indicating whether the given authentication is applied against staging or not.
+    @property
+    def is_staging(self) -> bool:
+        return "staging" in self._oauth_root
+
+    @pyqtProperty(bool, notify=loginStateChanged)
+    def isLoggedIn(self) -> bool:
+        return self._logged_in
+
+    def _onLoginStateChanged(self, logged_in: bool = False, error_message: Optional[str] = None) -> None:
+        if error_message:
+            if self._error_message:
+                self._error_message.hide()
+            self._error_message = Message(error_message, title = i18n_catalog.i18nc("@info:title", "Login failed"))
+            self._error_message.show()
+            self._logged_in = False
+            self.loginStateChanged.emit(False)
+            return
+
+        if self._logged_in != logged_in:
+            self._logged_in = logged_in
+            self.loginStateChanged.emit(logged_in)
+
+    @pyqtSlot()
+    def login(self) -> None:
+        if self._logged_in:
+            # Nothing to do, user already logged in.
+            return
+        self._authorization_service.startAuthorizationFlow()
+
+    @pyqtProperty(str, notify=loginStateChanged)
+    def userName(self):
+        user_profile = self._authorization_service.getUserProfile()
+        if not user_profile:
+            return None
+        return user_profile.username
+
+    @pyqtProperty(str, notify = loginStateChanged)
+    def profileImageUrl(self):
+        user_profile = self._authorization_service.getUserProfile()
+        if not user_profile:
+            return None
+        return user_profile.profile_image_url
+
+    @pyqtProperty(str, notify=loginStateChanged)
+    def accessToken(self) -> Optional[str]:
+        return self._authorization_service.getAccessToken()
+
+    #   Get the profile of the logged in user
+    #   @returns None if no user is logged in, a dict containing user_id, username and profile_image_url
+    @pyqtProperty("QVariantMap", notify = loginStateChanged)
+    def userProfile(self) -> Optional[Dict[str, Optional[str]]]:
+        user_profile = self._authorization_service.getUserProfile()
+        if not user_profile:
+            return None
+        return user_profile.__dict__
+
+    @pyqtSlot()
+    def logout(self) -> None:
+        if not self._logged_in:
+            return  # Nothing to do, user isn't logged in.
+
+        self._authorization_service.deleteAuthData()

cura/API/Backups.py

@@ -1,9 +1,12 @@
 # Copyright (c) 2018 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
-from typing import Tuple, Optional
+from typing import Tuple, Optional, TYPE_CHECKING, Dict, Any
 
 from cura.Backups.BackupsManager import BackupsManager
 
+if TYPE_CHECKING:
+    from cura.CuraApplication import CuraApplication
+
 
 ##  The back-ups API provides a version-proof bridge between Cura's
 #   BackupManager and plug-ins that hook into it.
@@ -13,19 +16,20 @@ from cura.Backups.BackupsManager import BackupsManager
 #       api = CuraAPI()
 #       api.backups.createBackup()
 #       api.backups.restoreBackup(my_zip_file, {"cura_release": "3.1"})``
-
 class Backups:
-    manager = BackupsManager()  # Re-used instance of the backups manager.
+
+    def __init__(self, application: "CuraApplication") -> None:
+        self.manager = BackupsManager(application)
 
     ##  Create a new back-up using the BackupsManager.
     #   \return Tuple containing a ZIP file with the back-up data and a dict
     #   with metadata about the back-up.
-    def createBackup(self) -> Tuple[Optional[bytes], Optional[dict]]:
+    def createBackup(self) -> Tuple[Optional[bytes], Optional[Dict[str, Any]]]:
         return self.manager.createBackup()
 
     ##  Restore a back-up using the BackupsManager.
     #   \param zip_file A ZIP file containing the actual back-up data.
     #   \param meta_data Some metadata needed for restoring a back-up, like the
     #   Cura version number.
-    def restoreBackup(self, zip_file: bytes, meta_data: dict) -> None:
+    def restoreBackup(self, zip_file: bytes, meta_data: Dict[str, Any]) -> None:
         return self.manager.restoreBackup(zip_file, meta_data)

cura/API/Interface/Settings.py

@@ -1,7 +1,11 @@
 # Copyright (c) 2018 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
 
-from cura.CuraApplication import CuraApplication
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from cura.CuraApplication import CuraApplication
+
 
 ##  The Interface.Settings API provides a version-proof bridge between Cura's
 #   (currently) sidebar UI and plug-ins that hook into it.
@@ -19,8 +23,9 @@ from cura.CuraApplication import CuraApplication
 #       api.interface.settings.addContextMenuItem(data)``
 
 class Settings:
-    # Re-used instance of Cura:
-    application = CuraApplication.getInstance()  # type: CuraApplication
+
+    def __init__(self, application: "CuraApplication") -> None:
+        self.application = application
 
     ##  Add items to the sidebar context menu.
     #   \param menu_item dict containing the menu item to add.
@@ -30,4 +35,4 @@ class Settings:
     ##  Get all custom items currently added to the sidebar context menu.
     #   \return List containing all custom context menu items.
     def getContextMenuItems(self) -> list:
-        return self.application.getSidebarCustomMenuItems()
+        return self.application.getSidebarCustomMenuItems()

cura/API/Interface/__init__.py

@@ -1,9 +1,14 @@
 # Copyright (c) 2018 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
 
-from UM.PluginRegistry import PluginRegistry
+from typing import TYPE_CHECKING
+
 from cura.API.Interface.Settings import Settings
 
+if TYPE_CHECKING:
+    from cura.CuraApplication import CuraApplication
+
+
 ##  The Interface class serves as a common root for the specific API
 #   methods for each interface element.
 #
@@ -17,8 +22,6 @@ from cura.API.Interface.Settings import Settings
 
 class Interface:
 
-    # For now we use the same API version to be consistent.
-    VERSION = PluginRegistry.APIVersion
-
-    # API methods specific to the settings portion of the UI
-    settings = Settings()
+    def __init__(self, application: "CuraApplication") -> None:
+        # API methods specific to the settings portion of the UI
+        self.settings = Settings(application)

cura/API/__init__.py

@@ -1,8 +1,16 @@
 # Copyright (c) 2018 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
-from UM.PluginRegistry import PluginRegistry
+from typing import Optional, TYPE_CHECKING
+
+from PyQt5.QtCore import QObject, pyqtProperty
+
 from cura.API.Backups import Backups
 from cura.API.Interface import Interface
+from cura.API.Account import Account
+
+if TYPE_CHECKING:
+    from cura.CuraApplication import CuraApplication
+
 
 ##  The official Cura API that plug-ins can use to interact with Cura.
 #
@@ -10,14 +18,46 @@ from cura.API.Interface import Interface
 #   this API provides a version-safe interface with proper deprecation warnings
 #   etc. Usage of any other methods than the ones provided in this API can cause
 #   plug-ins to be unstable.
-
-class CuraAPI:
+class CuraAPI(QObject):
 
     # For now we use the same API version to be consistent.
-    VERSION = PluginRegistry.APIVersion
+    __instance = None  # type: "CuraAPI"
+    _application = None  # type: CuraApplication
 
-    # Backups API
-    backups = Backups()
+    #   This is done to ensure that the first time an instance is created, it's forced that the application is set.
+    #   The main reason for this is that we want to prevent consumers of API to have a dependency on CuraApplication.
+    #   Since the API is intended to be used by plugins, the cura application should have already created this.
+    def __new__(cls, application: Optional["CuraApplication"] = None):
+        if cls.__instance is None:
+            if application is None:
+                raise Exception("Upon first time creation, the application must be set.")
+            cls.__instance = super(CuraAPI, cls).__new__(cls)
+            cls._application = application
+        return cls.__instance
 
-    # Interface API
-    interface = Interface()
+    def __init__(self, application: Optional["CuraApplication"] = None) -> None:
+        super().__init__(parent = CuraAPI._application)
+
+        # Accounts API
+        self._account = Account(self._application)
+
+        # Backups API
+        self._backups = Backups(self._application)
+
+        # Interface API
+        self._interface = Interface(self._application)
+
+    def initialize(self) -> None:
+        self._account.initialize()
+
+    @pyqtProperty(QObject, constant = True)
+    def account(self) -> "Account":
+        return self._account
+
+    @property
+    def backups(self) -> "Backups":
+        return self._backups
+
+    @property
+    def interface(self) -> "Interface":
+        return self._interface

cura/ApplicationMetadata.py

@@ -0,0 +1,50 @@
+# Copyright (c) 2018 Ultimaker B.V.
+# 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_BUILD_TYPE = ""
+DEFAULT_CURA_DEBUG_MODE = False
+DEFAULT_CURA_SDK_VERSION = "6.0.0"
+
+try:
+    from cura.CuraVersion import CuraAppName  # type: ignore
+    if CuraAppName == "":
+        CuraAppName = DEFAULT_CURA_APP_NAME
+except ImportError:
+    CuraAppName = DEFAULT_CURA_APP_NAME
+
+try:
+    from cura.CuraVersion import CuraAppDisplayName  # type: ignore
+    if CuraAppDisplayName == "":
+        CuraAppDisplayName = DEFAULT_CURA_DISPLAY_NAME
+except ImportError:
+    CuraAppDisplayName = DEFAULT_CURA_DISPLAY_NAME
+
+try:
+    from cura.CuraVersion import CuraVersion  # type: ignore
+    if CuraVersion == "":
+        CuraVersion = DEFAULT_CURA_VERSION
+except ImportError:
+    CuraVersion = DEFAULT_CURA_VERSION  # [CodeStyle: Reflecting imported value]
+
+try:
+    from cura.CuraVersion import CuraBuildType  # type: ignore
+except ImportError:
+    CuraBuildType = DEFAULT_CURA_BUILD_TYPE
+
+try:
+    from cura.CuraVersion import CuraDebugMode  # type: ignore
+except ImportError:
+    CuraDebugMode = DEFAULT_CURA_DEBUG_MODE
+
+try:
+    from cura.CuraVersion import CuraSDKVersion  # type: ignore
+    if CuraSDKVersion == "":
+        CuraSDKVersion = DEFAULT_CURA_SDK_VERSION
+except ImportError:
+    CuraSDKVersion = DEFAULT_CURA_SDK_VERSION

cura/Arranging/Arrange.py

@@ -66,6 +66,11 @@ class Arrange:
                 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 len(points) == 0:
+                continue
+
             shape_arr = ShapeArray.fromPolygon(points, scale = scale)
             arranger.place(0, 0, shape_arr)
 

cura/Arranging/ArrangeObjectsJob.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2017 Ultimaker B.V.
+# Copyright (c) 2019 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
 
 from UM.Application import Application
@@ -39,10 +39,17 @@ class ArrangeObjectsJob(Job):
 
         arranger = Arrange.create(x = machine_width, y = machine_depth, fixed_nodes = self._fixed_nodes, min_offset = self._min_offset)
 
+        # Build set to exclude children (those get arranged together with the parents).
+        included_as_child = set()
+        for node in self._nodes:
+            included_as_child.update(node.getAllChildren())
+
         # 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)
+            if node in included_as_child:
+                continue
+            offset_shape_arr, hull_shape_arr = ShapeArray.fromNode(node, min_offset = self._min_offset, include_children = True)
             if offset_shape_arr is None:
                 Logger.log("w", "Node [%s] could not be converted to an array for arranging...", str(node))
                 continue

cura/Arranging/ShapeArray.py

@@ -42,7 +42,7 @@ class ShapeArray:
     #   \param min_offset offset for the offset ShapeArray
     #   \param scale scale the coordinates
     @classmethod
-    def fromNode(cls, node, min_offset, scale = 0.5):
+    def fromNode(cls, node, min_offset, scale = 0.5, include_children = False):
         transform = node._transformation
         transform_x = transform._data[0][3]
         transform_y = transform._data[2][3]
@@ -52,6 +52,21 @@ class ShapeArray:
             return None, None
         # For one_at_a_time printing you need the convex hull head.
         hull_head_verts = node.callDecoration("getConvexHullHead") or hull_verts
+        if hull_head_verts is None:
+            hull_head_verts = Polygon()
+
+        # If the child-nodes are included, adjust convex hulls as well:
+        if include_children:
+            children = node.getAllChildren()
+            if not children is 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:
+                        hull_verts = hull_verts.unionConvexHulls(child_hull)
+                    child_hull_head = child.callDecoration("getConvexHullHead") or child_hull
+                    if not child_hull_head is None:
+                        hull_head_verts = hull_head_verts.unionConvexHulls(child_hull_head)
 
         offset_verts = hull_head_verts.getMinkowskiHull(Polygon.approximatedCircle(min_offset))
         offset_points = copy.deepcopy(offset_verts._points)  # x, y

cura/Backups/Backup.py

@@ -4,18 +4,18 @@
 import io
 import os
 import re
-
 import shutil
-
-from typing import Dict, Optional
 from zipfile import ZipFile, ZIP_DEFLATED, BadZipfile
+from typing import Dict, Optional, TYPE_CHECKING
 
 from UM import i18nCatalog
 from UM.Logger import Logger
 from UM.Message import Message
 from UM.Platform import Platform
 from UM.Resources import Resources
-from cura.CuraApplication import CuraApplication
+
+if TYPE_CHECKING:
+    from cura.CuraApplication import CuraApplication
 
 
 ##  The back-up class holds all data about a back-up.
@@ -29,28 +29,30 @@ class Backup:
     # Re-use translation catalog.
     catalog = i18nCatalog("cura")
 
-    def __init__(self, zip_file: bytes = None, meta_data: Dict[str, str] = None) -> None:
+    def __init__(self, application: "CuraApplication", zip_file: bytes = None, meta_data: Dict[str, str] = None) -> None:
+        self._application = application
         self.zip_file = zip_file  # type: Optional[bytes]
         self.meta_data = meta_data  # type: Optional[Dict[str, str]]
 
     ##  Create a back-up from the current user config folder.
     def makeFromCurrent(self) -> None:
-        cura_release = CuraApplication.getInstance().getVersion()
+        cura_release = self._application.getVersion()
         version_data_dir = Resources.getDataStoragePath()
 
         Logger.log("d", "Creating backup for Cura %s, using folder %s", cura_release, version_data_dir)
 
         # Ensure all current settings are saved.
-        CuraApplication.getInstance().saveSettings()
+        self._application.saveSettings()
 
         # We copy the preferences file to the user data directory in Linux as it's in a different location there.
         # When restoring a backup on Linux, we move it back.
-        if Platform.isLinux():
-            preferences_file_name = CuraApplication.getInstance().getApplicationName()
+        if Platform.isLinux(): #TODO: This should check for the config directory not being the same as the data directory, rather than hard-coding that to Linux systems.
+            preferences_file_name = self._application.getApplicationName()
             preferences_file = Resources.getPath(Resources.Preferences, "{}.cfg".format(preferences_file_name))
             backup_preferences_file = os.path.join(version_data_dir, "{}.cfg".format(preferences_file_name))
-            Logger.log("d", "Copying preferences file from %s to %s", preferences_file, backup_preferences_file)
-            shutil.copyfile(preferences_file, backup_preferences_file)
+            if os.path.exists(preferences_file) and (not os.path.exists(backup_preferences_file) or not os.path.samefile(preferences_file, backup_preferences_file)):
+                Logger.log("d", "Copying preferences file from %s to %s", preferences_file, backup_preferences_file)
+                shutil.copyfile(preferences_file, backup_preferences_file)
 
         # Create an empty buffer and write the archive to it.
         buffer = io.BytesIO()
@@ -58,7 +60,7 @@ class Backup:
         if archive is None:
             return
         files = archive.namelist()
-        
+
         # Count the metadata items. We do this in a rather naive way at the moment.
         machine_count = len([s for s in files if "machine_instances/" in s]) - 1
         material_count = len([s for s in files if "materials/" in s]) - 1
@@ -112,7 +114,7 @@ class Backup:
                                    "Tried to restore a Cura backup without having proper data or meta data."))
             return False
 
-        current_version = CuraApplication.getInstance().getVersion()
+        current_version = self._application.getVersion()
         version_to_restore = self.meta_data.get("cura_release", "master")
         if current_version != version_to_restore:
             # Cannot restore version older or newer than current because settings might have changed.
@@ -128,7 +130,7 @@ class Backup:
 
         # Under Linux, preferences are stored elsewhere, so we copy the file to there.
         if Platform.isLinux():
-            preferences_file_name = CuraApplication.getInstance().getApplicationName()
+            preferences_file_name = self._application.getApplicationName()
             preferences_file = Resources.getPath(Resources.Preferences, "{}.cfg".format(preferences_file_name))
             backup_preferences_file = os.path.join(version_data_dir, "{}.cfg".format(preferences_file_name))
             Logger.log("d", "Moving preferences file from %s to %s", backup_preferences_file, preferences_file)

cura/Backups/BackupsManager.py

@@ -1,11 +1,13 @@
 # Copyright (c) 2018 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
 
-from typing import Dict, Optional, Tuple
+from typing import Dict, Optional, Tuple, TYPE_CHECKING
 
 from UM.Logger import Logger
 from cura.Backups.Backup import Backup
-from cura.CuraApplication import CuraApplication
+
+if TYPE_CHECKING:
+    from cura.CuraApplication import CuraApplication
 
 
 ##  The BackupsManager is responsible for managing the creating and restoring of
@@ -13,15 +15,15 @@ from cura.CuraApplication import CuraApplication
 #
 #   Back-ups themselves are represented in a different class.
 class BackupsManager:
-    def __init__(self):
-        self._application = CuraApplication.getInstance()
+    def __init__(self, application: "CuraApplication") -> None:
+        self._application = application
 
     ##  Get a back-up of the current configuration.
     #   \return A tuple containing a ZipFile (the actual back-up) and a dict
     #   containing some metadata (like version).
     def createBackup(self) -> Tuple[Optional[bytes], Optional[Dict[str, str]]]:
         self._disableAutoSave()
-        backup = Backup()
+        backup = Backup(self._application)
         backup.makeFromCurrent()
         self._enableAutoSave()
         # We don't return a Backup here because we want plugins only to interact with our API and not full objects.
@@ -39,7 +41,7 @@ class BackupsManager:
 
         self._disableAutoSave()
 
-        backup = Backup(zip_file = zip_file, meta_data = meta_data)
+        backup = Backup(self._application, zip_file = zip_file, meta_data = meta_data)
         restored = backup.restore()
         if restored:
             # At this point, Cura will need to restart for the changes to take effect.

cura/BuildVolume.py

@@ -1,6 +1,6 @@
 # Copyright (c) 2018 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
-
+from UM.Scene.Camera import Camera
 from cura.Scene.CuraSceneNode import CuraSceneNode
 from cura.Settings.ExtruderManager import ExtruderManager
 from UM.Application import Application #To modify the maximum zoom level.
@@ -28,7 +28,7 @@ import copy
 
 from typing import List, Optional
 
-# Setting for clearance around the prime
+# Radius of disallowed area in mm around prime. I.e. how much distance to keep from prime position.
 PRIME_CLEARANCE = 6.5
 
 
@@ -83,7 +83,14 @@ class BuildVolume(SceneNode):
             " with printed models."), title = catalog.i18nc("@info:title", "Build Volume"))
 
         self._global_container_stack = None
+
+        self._stack_change_timer = QTimer()
+        self._stack_change_timer.setInterval(100)
+        self._stack_change_timer.setSingleShot(True)
+        self._stack_change_timer.timeout.connect(self._onStackChangeTimerFinished)
+
         self._application.globalContainerStackChanged.connect(self._onStackChanged)
+
         self._onStackChanged()
 
         self._engine_ready = False
@@ -122,7 +129,9 @@ class BuildVolume(SceneNode):
 
     def _onSceneChanged(self, source):
         if self._global_container_stack:
-            self._scene_change_timer.start()
+            # Ignore anything that is not something we can slice in the first place!
+            if source.callDecoration("isSliceable"):
+                self._scene_change_timer.start()
 
     def _onSceneChangeTimerFinished(self):
         root = self._application.getController().getScene().getRoot()
@@ -139,7 +148,7 @@ class BuildVolume(SceneNode):
                 if active_extruder_changed is not None:
                     node.callDecoration("getActiveExtruderChangedSignal").disconnect(self._updateDisallowedAreasAndRebuild)
                 node.decoratorsChanged.disconnect(self._updateNodeListeners)
-            self._updateDisallowedAreasAndRebuild()  # make sure we didn't miss anything before we updated the node listeners
+            self.rebuild()
 
             self._scene_objects = new_scene_objects
             self._onSettingPropertyChanged("print_sequence", "value")  # Create fake event, so right settings are triggered.
@@ -491,7 +500,9 @@ class BuildVolume(SceneNode):
 
     def _updateRaftThickness(self):
         old_raft_thickness = self._raft_thickness
-        self._adhesion_type = self._global_container_stack.getProperty("adhesion_type", "value")
+        if self._global_container_stack.extruders:
+            # This might be called before the extruder stacks have initialised, in which case getting the adhesion_type fails
+            self._adhesion_type = self._global_container_stack.getProperty("adhesion_type", "value")
         self._raft_thickness = 0.0
         if self._adhesion_type == "raft":
             self._raft_thickness = (
@@ -524,11 +535,14 @@ class BuildVolume(SceneNode):
         if extra_z != self._extra_z_clearance:
             self._extra_z_clearance = extra_z
 
-    ##  Update the build volume visualization
     def _onStackChanged(self):
+        self._stack_change_timer.start()
+
+    ##  Update the build volume visualization
+    def _onStackChangeTimerFinished(self):
         if self._global_container_stack:
             self._global_container_stack.propertyChanged.disconnect(self._onSettingPropertyChanged)
-            extruders = ExtruderManager.getInstance().getMachineExtruders(self._global_container_stack.getId())
+            extruders = ExtruderManager.getInstance().getActiveExtruderStacks()
             for extruder in extruders:
                 extruder.propertyChanged.disconnect(self._onSettingPropertyChanged)
 
@@ -536,7 +550,7 @@ class BuildVolume(SceneNode):
 
         if self._global_container_stack:
             self._global_container_stack.propertyChanged.connect(self._onSettingPropertyChanged)
-            extruders = ExtruderManager.getInstance().getMachineExtruders(self._global_container_stack.getId())
+            extruders = ExtruderManager.getInstance().getActiveExtruderStacks()
             for extruder in extruders:
                 extruder.propertyChanged.connect(self._onSettingPropertyChanged)
 
@@ -653,6 +667,7 @@ class BuildVolume(SceneNode):
     #   ``_updateDisallowedAreas`` method itself shouldn't call ``rebuild``,
     #   since there may be other changes before it needs to be rebuilt, which
     #   would hit performance.
+
     def _updateDisallowedAreasAndRebuild(self):
         self._updateDisallowedAreas()
         self._updateRaftThickness()
@@ -720,21 +735,27 @@ class BuildVolume(SceneNode):
 
         # Add prime tower location as disallowed area.
         if len(used_extruders) > 1: #No prime tower in single-extrusion.
-            prime_tower_collision = False
-            prime_tower_areas = self._computeDisallowedAreasPrinted(used_extruders)
-            for extruder_id in prime_tower_areas:
-                for prime_tower_area in prime_tower_areas[extruder_id]:
-                    for area in result_areas[extruder_id]:
-                        if prime_tower_area.intersectsPolygon(area) is not None:
-                            prime_tower_collision = True
+
+            if len([x for x in used_extruders if x.isEnabled == True]) > 1: #No prime tower if only one extruder is enabled
+                prime_tower_collision = False
+                prime_tower_areas = self._computeDisallowedAreasPrinted(used_extruders)
+                for extruder_id in prime_tower_areas:
+                    for i_area, prime_tower_area in enumerate(prime_tower_areas[extruder_id]):
+                        for area in result_areas[extruder_id]:
+                            if prime_tower_area.intersectsPolygon(area) is not None:
+                                prime_tower_collision = True
+                                break
+                        if prime_tower_collision: #Already found a collision.
                             break
-                    if prime_tower_collision: #Already found a collision.
-                        break
-                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])
-                else:
-                    self._error_areas.extend(prime_tower_areas[extruder_id])
+                        if (ExtruderManager.getInstance().getResolveOrValue("prime_tower_brim_enable") and
+                            ExtruderManager.getInstance().getResolveOrValue("adhesion_type") != "raft"):
+                            prime_tower_areas[extruder_id][i_area] = prime_tower_area.getMinkowskiHull(
+                                Polygon.approximatedCircle(disallowed_border_size))
+                    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])
+                    else:
+                        self._error_areas.extend(prime_tower_areas[extruder_id])
 
         self._has_errors = len(self._error_areas) > 0
 
@@ -769,6 +790,16 @@ 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 (ExtruderManager.getInstance().getResolveOrValue("prime_tower_brim_enable") and
+                ExtruderManager.getInstance().getResolveOrValue("adhesion_type") != "raft"):
+                brim_size = (
+                    extruder.getProperty("brim_line_count", "value") *
+                    extruder.getProperty("skirt_brim_line_width", "value") / 100.0 *
+                    extruder.getProperty("initial_layer_line_width_factor", "value")
+                )
+                prime_tower_x -= brim_size
+                prime_tower_y += brim_size
+
             if self._global_container_stack.getProperty("prime_tower_circular", "value"):
                 radius = prime_tower_size / 2
                 prime_tower_area = Polygon.approximatedCircle(radius)
@@ -1008,7 +1039,9 @@ class BuildVolume(SceneNode):
             # 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 == "brim":
+        elif (adhesion_type == "brim" or
+                (self._global_container_stack.getProperty("prime_tower_brim_enable", "value") and
+                    self._global_container_stack.getProperty("adhesion_type", "value") != "raft")):
             brim_line_count = self._global_container_stack.getProperty("brim_line_count", "value")
             bed_adhesion_size = skirt_brim_line_width * brim_line_count * initial_layer_line_width_factor / 100.0
 
@@ -1027,6 +1060,12 @@ class BuildVolume(SceneNode):
         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"),
+            self._global_container_stack.getProperty("machine_depth", "value")
+        )
+        bed_adhesion_size = min(bed_adhesion_size, max_length_available)
+
         support_expansion = 0
         support_enabled = self._global_container_stack.getProperty("support_enable", "value")
         support_offset = self._global_container_stack.getProperty("support_offset", "value")
@@ -1061,7 +1100,7 @@ class BuildVolume(SceneNode):
     _raft_settings = ["adhesion_type", "raft_base_thickness", "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", "extruder_prime_pos_z", "prime_blob_enable"]
-    _tower_settings = ["prime_tower_enable", "prime_tower_circular", "prime_tower_size", "prime_tower_position_x", "prime_tower_position_y"]
+    _tower_settings = ["prime_tower_enable", "prime_tower_circular", "prime_tower_size", "prime_tower_position_x", "prime_tower_position_y", "prime_tower_brim_enable"]
     _ooze_shield_settings = ["ooze_shield_enabled", "ooze_shield_dist"]
     _distance_settings = ["infill_wipe_dist", "travel_avoid_distance", "support_offset", "support_enable", "travel_avoid_other_parts", "travel_avoid_supports"]
     _extruder_settings = ["support_enable", "support_bottom_enable", "support_roof_enable", "support_infill_extruder_nr", "support_extruder_nr_layer_0", "support_bottom_extruder_nr", "support_roof_extruder_nr", "brim_line_count", "adhesion_extruder_nr", "adhesion_type"] #Settings that can affect which extruders are used.

cura/CameraImageProvider.py

@@ -1,23 +0,0 @@
-from PyQt5.QtGui import QImage
-from PyQt5.QtQuick import QQuickImageProvider
-from PyQt5.QtCore import QSize
-
-from UM.Application import Application
-
-
-class CameraImageProvider(QQuickImageProvider):
-    def __init__(self):
-        super().__init__(QQuickImageProvider.Image)
-
-    ##  Request a new image.
-    def requestImage(self, id, size):
-        for output_device in Application.getInstance().getOutputDeviceManager().getOutputDevices():
-            try:
-                image = output_device.activePrinter.camera.getImage()
-                if image.isNull():
-                    image = QImage()
-
-                return image, QSize(15, 15)
-            except AttributeError:
-                pass
-        return QImage(), QSize(15, 15)

cura/CrashHandler.py

@@ -36,18 +36,14 @@ else:
     except ImportError:
         CuraDebugMode = False  # [CodeStyle: Reflecting imported value]
 
-# List of exceptions that should be considered "fatal" and abort the program.
-# These are primarily some exception types that we simply cannot really recover from
-# (MemoryError and SystemError) and exceptions that indicate grave errors in the
-# code that cause the Python interpreter to fail (SyntaxError, ImportError).
-fatal_exception_types = [
-    MemoryError,
-    SyntaxError,
-    ImportError,
-    SystemError,
+# List of exceptions that should not be considered "fatal" and abort the program.
+# These are primarily some exception types that we simply skip
+skip_exception_types = [
+    SystemExit,
+    KeyboardInterrupt,
+    GeneratorExit
 ]
 
-
 class CrashHandler:
     crash_url = "https://stats.ultimaker.com/api/cura"
 
@@ -70,7 +66,7 @@ class CrashHandler:
         # If Cura has fully started, we only show fatal errors.
         # If Cura has not fully started yet, we always show the early crash dialog. Otherwise, Cura will just crash
         # without any information.
-        if has_started and exception_type not in fatal_exception_types:
+        if has_started and exception_type in skip_exception_types:
             return
 
         if not has_started:
@@ -387,7 +383,7 @@ class CrashHandler:
         Application.getInstance().callLater(self._show)
 
     def _show(self):
-        # When the exception is not in the fatal_exception_types list, the dialog is not created, so we don't need to show it
+        # 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_()
         os._exit(1)

cura/CuraActions.py

@@ -3,7 +3,7 @@
 
 from PyQt5.QtCore import QObject, QUrl
 from PyQt5.QtGui import QDesktopServices
-from typing import List, TYPE_CHECKING
+from typing import List, TYPE_CHECKING, cast
 
 from UM.Event import CallFunctionEvent
 from UM.FlameProfiler import pyqtSlot
@@ -36,12 +36,12 @@ class CuraActions(QObject):
         # Starting a web browser from a signal handler connected to a menu will crash on windows.
         # So instead, defer the call to the next run of the event loop, since that does work.
         # Note that weirdly enough, only signal handlers that open a web browser fail like that.
-        event = CallFunctionEvent(self._openUrl, [QUrl("http://ultimaker.com/en/support/software")], {})
+        event = CallFunctionEvent(self._openUrl, [QUrl("https://ultimaker.com/en/resources/manuals/software")], {})
         cura.CuraApplication.CuraApplication.getInstance().functionEvent(event)
 
     @pyqtSlot()
     def openBugReportPage(self) -> None:
-        event = CallFunctionEvent(self._openUrl, [QUrl("http://github.com/Ultimaker/Cura/issues")], {})
+        event = CallFunctionEvent(self._openUrl, [QUrl("https://github.com/Ultimaker/Cura/issues")], {})
         cura.CuraApplication.CuraApplication.getInstance().functionEvent(event)
 
     ##  Reset camera position and direction to default
@@ -61,8 +61,10 @@ class CuraActions(QObject):
         operation = GroupedOperation()
         for node in Selection.getAllSelectedObjects():
             current_node = node
-            while current_node.getParent() and current_node.getParent().callDecoration("isGroup"):
-                current_node = current_node.getParent()
+            parent_node = current_node.getParent()
+            while parent_node and parent_node.callDecoration("isGroup"):
+                current_node = parent_node
+                parent_node = current_node.getParent()
 
             #   This was formerly done with SetTransformOperation but because of
             #   unpredictable matrix deconstruction it was possible that mirrors
@@ -150,13 +152,13 @@ class CuraActions(QObject):
 
         root = cura.CuraApplication.CuraApplication.getInstance().getController().getScene().getRoot()
 
-        nodes_to_change = []
+        nodes_to_change = []  # type: List[SceneNode]
         for node in Selection.getAllSelectedObjects():
             parent_node = node  # Find the parent node to change instead
             while parent_node.getParent() != root:
-                parent_node = parent_node.getParent()
+                parent_node = cast(SceneNode, parent_node.getParent())
 
-            for single_node in BreadthFirstIterator(parent_node): #type: ignore #Ignore type error because iter() should get called automatically by Python syntax.
+            for single_node in BreadthFirstIterator(parent_node):  # type: ignore #Ignore type error because iter() should get called automatically by Python syntax.
                 nodes_to_change.append(single_node)
 
         if not nodes_to_change:

cura/CuraApplication.py

@@ -1,10 +1,10 @@
-# Copyright (c) 2018 Ultimaker B.V.
+# Copyright (c) 2019 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
 
 import os
 import sys
 import time
-from typing import cast, TYPE_CHECKING
+from typing import cast, TYPE_CHECKING, Optional, Callable, List
 
 import numpy
 
@@ -13,6 +13,8 @@ from PyQt5.QtGui import QColor, QIcon
 from PyQt5.QtWidgets import QMessageBox
 from PyQt5.QtQml import qmlRegisterUncreatableType, qmlRegisterSingletonType, qmlRegisterType
 
+from UM.Application import Application
+from UM.PluginError import PluginNotFoundError
 from UM.Scene.SceneNode import SceneNode
 from UM.Scene.Camera import Camera
 from UM.Math.Vector import Vector
@@ -36,18 +38,18 @@ from UM.Settings.Validator import Validator
 from UM.Message import Message
 from UM.i18n import i18nCatalog
 from UM.Workspace.WorkspaceReader import WorkspaceReader
-from UM.Decorators import deprecated
 
 from UM.Operations.AddSceneNodeOperation import AddSceneNodeOperation
-from UM.Operations.RemoveSceneNodeOperation import RemoveSceneNodeOperation
 from UM.Operations.GroupedOperation import GroupedOperation
 from UM.Operations.SetTransformOperation import SetTransformOperation
 
+from cura.API import CuraAPI
 from cura.Arranging.Arrange import Arrange
 from cura.Arranging.ArrangeObjectsJob import ArrangeObjectsJob
 from cura.Arranging.ArrangeObjectsAllBuildPlatesJob import ArrangeObjectsAllBuildPlatesJob
 from cura.Arranging.ShapeArray import ShapeArray
 from cura.MultiplyObjectsJob import MultiplyObjectsJob
+from cura.GlobalStacksModel import GlobalStacksModel
 from cura.Scene.ConvexHullDecorator import ConvexHullDecorator
 from cura.Operations.SetParentOperation import SetParentOperation
 from cura.Scene.SliceableObjectDecorator import SliceableObjectDecorator
@@ -60,6 +62,7 @@ from cura.Scene.CuraSceneController import CuraSceneController
 from UM.Settings.SettingDefinition import SettingDefinition, DefinitionPropertyType
 from UM.Settings.ContainerRegistry import ContainerRegistry
 from UM.Settings.SettingFunction import SettingFunction
+from cura.Settings.CuraContainerRegistry import CuraContainerRegistry
 from cura.Settings.MachineNameValidator import MachineNameValidator
 
 from cura.Machines.Models.BuildPlateModel import BuildPlateModel
@@ -67,9 +70,9 @@ from cura.Machines.Models.NozzleModel import NozzleModel
 from cura.Machines.Models.QualityProfilesDropDownMenuModel import QualityProfilesDropDownMenuModel
 from cura.Machines.Models.CustomQualityProfilesDropDownMenuModel import CustomQualityProfilesDropDownMenuModel
 from cura.Machines.Models.MultiBuildPlateModel import MultiBuildPlateModel
-from cura.Machines.Models.MaterialManagementModel import MaterialManagementModel
+from cura.Machines.Models.FavoriteMaterialsModel import FavoriteMaterialsModel
 from cura.Machines.Models.GenericMaterialsModel import GenericMaterialsModel
-from cura.Machines.Models.BrandMaterialsModel import BrandMaterialsModel
+from cura.Machines.Models.MaterialBrandsModel import MaterialBrandsModel
 from cura.Machines.Models.QualityManagementModel import QualityManagementModel
 from cura.Machines.Models.QualitySettingsModel import QualitySettingsModel
 from cura.Machines.Models.MachineManagementModel import MachineManagementModel
@@ -92,7 +95,7 @@ from . import PrintInformation
 from . import CuraActions
 from cura.Scene import ZOffsetDecorator
 from . import CuraSplashScreen
-from . import CameraImageProvider
+from . import PrintJobPreviewImageProvider
 from . import MachineActionManager
 
 from cura.TaskManagement.OnExitCallbackManager import OnExitCallbackManager
@@ -105,32 +108,33 @@ from cura.Settings.MaterialSettingsVisibilityHandler import MaterialSettingsVisi
 from cura.Settings.ContainerManager import ContainerManager
 from cura.Settings.SidebarCustomMenuItemsModel import SidebarCustomMenuItemsModel
 import cura.Settings.cura_empty_instance_containers
+from cura.Settings.CuraFormulaFunctions import CuraFormulaFunctions
 
 from cura.ObjectsModel import ObjectsModel
 
-from UM.FlameProfiler import pyqtSlot
+from cura.PrinterOutputDevice import PrinterOutputDevice
+from cura.PrinterOutput.NetworkMJPGImage import NetworkMJPGImage
 
+from cura import ApplicationMetadata, UltimakerCloudAuthentication
+
+from UM.FlameProfiler import pyqtSlot
+from UM.Decorators import override
 
 if TYPE_CHECKING:
-    from plugins.SliceInfoPlugin.SliceInfo import SliceInfo
+    from cura.Machines.MaterialManager import MaterialManager
+    from cura.Machines.QualityManager import QualityManager
+    from UM.Settings.EmptyInstanceContainer import EmptyInstanceContainer
+    from cura.Settings.GlobalStack import GlobalStack
 
 
 numpy.seterr(all = "ignore")
 
-try:
-    from cura.CuraVersion import CuraVersion, CuraBuildType, CuraDebugMode, CuraSDKVersion
-except ImportError:
-    CuraVersion = "master"  # [CodeStyle: Reflecting imported value]
-    CuraBuildType = ""
-    CuraDebugMode = False
-    CuraSDKVersion = ""
-
 
 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 = 5
+    SettingVersion = 7
 
     Created = False
 
@@ -150,15 +154,19 @@ class CuraApplication(QtApplication):
     Q_ENUMS(ResourceTypes)
 
     def __init__(self, *args, **kwargs):
-        super().__init__(name = "cura",
-                         version = CuraVersion,
-                         buildtype = CuraBuildType,
-                         is_debug_mode = CuraDebugMode,
+        super().__init__(name = ApplicationMetadata.CuraAppName,
+                         app_display_name = ApplicationMetadata.CuraAppDisplayName,
+                         version = ApplicationMetadata.CuraVersion,
+                         api_version = ApplicationMetadata.CuraSDKVersion,
+                         buildtype = ApplicationMetadata.CuraBuildType,
+                         is_debug_mode = ApplicationMetadata.CuraDebugMode,
                          tray_icon_name = "cura-icon-32.png",
                          **kwargs)
 
         self.default_theme = "cura-light"
 
+        self.change_log_url = "https://ultimaker.com/ultimaker-cura-latest-features"
+
         self._boot_loading_time = time.time()
 
         self._on_exit_callback_manager = OnExitCallbackManager(self)
@@ -166,20 +174,21 @@ class CuraApplication(QtApplication):
         # Variables set from CLI
         self._files_to_open = []
         self._use_single_instance = False
-        self._trigger_early_crash = False  # For debug only
 
         self._single_instance = None
 
+        self._cura_formula_functions = None  # type: Optional[CuraFormulaFunctions]
+
         self._cura_package_manager = None
 
         self._machine_action_manager = None
 
-        self.empty_container = None
-        self.empty_definition_changes_container = None
-        self.empty_variant_container = None
-        self.empty_material_container = None
-        self.empty_quality_container = None
-        self.empty_quality_changes_container = None
+        self.empty_container = None  # type: EmptyInstanceContainer
+        self.empty_definition_changes_container = None  # type: EmptyInstanceContainer
+        self.empty_variant_container = None  # type: EmptyInstanceContainer
+        self.empty_material_container = None  # type: EmptyInstanceContainer
+        self.empty_quality_container = None  # type: EmptyInstanceContainer
+        self.empty_quality_changes_container = None  # type: EmptyInstanceContainer
 
         self._variant_manager = None
         self._material_manager = None
@@ -189,6 +198,8 @@ class CuraApplication(QtApplication):
         self._container_manager = None
 
         self._object_manager = None
+        self._extruders_model = None
+        self._extruders_model_with_optional = None
         self._build_plate_model = None
         self._multi_build_plate_model = None
         self._setting_visibility_presets_model = None
@@ -199,6 +210,7 @@ class CuraApplication(QtApplication):
 
         self._quality_profile_drop_down_menu_model = None
         self._custom_quality_profile_drop_down_menu_model = None
+        self._cura_API = CuraAPI(self)
 
         self._physics = None
         self._volume = None
@@ -215,7 +227,6 @@ class CuraApplication(QtApplication):
 
         self._message_box_callback = None
         self._message_box_callback_arguments = []
-        self._preferred_mimetype = ""
         self._i18n_catalog = None
 
         self._currently_loading_files = []
@@ -238,9 +249,19 @@ class CuraApplication(QtApplication):
 
         from cura.Settings.CuraContainerRegistry import CuraContainerRegistry
         self._container_registry_class = CuraContainerRegistry
+        # Redefined here in order to please the typing.
+        self._container_registry = None # type: CuraContainerRegistry
         from cura.CuraPackageManager import CuraPackageManager
         self._package_manager_class = CuraPackageManager
 
+    @pyqtProperty(str, constant=True)
+    def ultimakerCloudApiRootUrl(self) -> str:
+        return UltimakerCloudAuthentication.CuraCloudAPIRoot
+
+    @pyqtProperty(str, constant = True)
+    def ultimakerCloudAccountRootUrl(self) -> str:
+        return UltimakerCloudAuthentication.CuraCloudAccountAPIRoot
+
     # Adds command line options to the command line parser. This should be called after the application is created and
     # before the pre-start.
     def addCommandLineOptions(self):
@@ -262,6 +283,9 @@ class CuraApplication(QtApplication):
                                       help = "FOR TESTING ONLY. Trigger an early crash to show the crash dialog.")
         self._cli_parser.add_argument("file", nargs = "*", help = "Files to load after starting the application.")
 
+    def getContainerRegistry(self) -> "CuraContainerRegistry":
+        return self._container_registry
+
     def parseCliOptions(self):
         super().parseCliOptions()
 
@@ -270,7 +294,10 @@ class CuraApplication(QtApplication):
             sys.exit(0)
 
         self._use_single_instance = self._cli_args.single_instance
-        self._trigger_early_crash = self._cli_args.trigger_early_crash
+        # FOR TESTING ONLY
+        if self._cli_args.trigger_early_crash:
+            assert not "This crash is triggered by the trigger_early_crash command line argument."
+
         for filename in self._cli_args.file:
             self._files_to_open.append(os.path.abspath(filename))
 
@@ -280,7 +307,8 @@ class CuraApplication(QtApplication):
         super().initialize()
 
         self.__sendCommandToSingleInstance()
-        self.__initializeSettingDefinitionsAndFunctions()
+        self._initializeSettingDefinitions()
+        self._initializeSettingFunctions()
         self.__addAllResourcesAndContainerResources()
         self.__addAllEmptyContainers()
         self.__setLatestResouceVersionsForVersionUpgrade()
@@ -288,8 +316,6 @@ class CuraApplication(QtApplication):
         self._machine_action_manager = MachineActionManager.MachineActionManager(self)
         self._machine_action_manager.initialize()
 
-        self.change_log_url = "https://ultimaker.com/ultimaker-cura-latest-features"
-
     def __sendCommandToSingleInstance(self):
         self._single_instance = SingleInstance(self, self._files_to_open)
 
@@ -311,33 +337,44 @@ class CuraApplication(QtApplication):
             resource_path = os.path.join(os.path.abspath(os.path.dirname(__file__)), "..", "resources")
             Resources.addSearchPath(resource_path)
 
-    # Adds custom property types, settings types, and extra operators (functions) that need to be registered in
-    # SettingDefinition and SettingFunction.
-    def __initializeSettingDefinitionsAndFunctions(self):
+    @classmethod
+    def _initializeSettingDefinitions(cls):
         # Need to do this before ContainerRegistry tries to load the machines
-        SettingDefinition.addSupportedProperty("settable_per_mesh", DefinitionPropertyType.Any, default = True, read_only = True)
-        SettingDefinition.addSupportedProperty("settable_per_extruder", DefinitionPropertyType.Any, default = True, read_only = True)
+        SettingDefinition.addSupportedProperty("settable_per_mesh", DefinitionPropertyType.Any, default=True,
+                                               read_only=True)
+        SettingDefinition.addSupportedProperty("settable_per_extruder", DefinitionPropertyType.Any, default=True,
+                                               read_only=True)
         # this setting can be changed for each group in one-at-a-time mode
-        SettingDefinition.addSupportedProperty("settable_per_meshgroup", DefinitionPropertyType.Any, default = True, read_only = True)
-        SettingDefinition.addSupportedProperty("settable_globally", DefinitionPropertyType.Any, default = True, read_only = True)
+        SettingDefinition.addSupportedProperty("settable_per_meshgroup", DefinitionPropertyType.Any, default=True,
+                                               read_only=True)
+        SettingDefinition.addSupportedProperty("settable_globally", DefinitionPropertyType.Any, default=True,
+                                               read_only=True)
 
         # From which stack the setting would inherit if not defined per object (handled in the engine)
         # AND for settings which are not settable_per_mesh:
         # which extruder is the only extruder this setting is obtained from
-        SettingDefinition.addSupportedProperty("limit_to_extruder", DefinitionPropertyType.Function, default = "-1", depends_on = "value")
+        SettingDefinition.addSupportedProperty("limit_to_extruder", DefinitionPropertyType.Function, default="-1",
+                                               depends_on="value")
 
         # For settings which are not settable_per_mesh and not settable_per_extruder:
         # A function which determines the glabel/meshgroup value by looking at the values of the setting in all (used) extruders
-        SettingDefinition.addSupportedProperty("resolve", DefinitionPropertyType.Function, default = None, depends_on = "value")
+        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("[int]", None, str, None)
 
-        SettingFunction.registerOperator("extruderValues", ExtruderManager.getExtruderValues)
-        SettingFunction.registerOperator("extruderValue", ExtruderManager.getExtruderValue)
-        SettingFunction.registerOperator("resolveOrValue", ExtruderManager.getResolveOrValue)
-        SettingFunction.registerOperator("defaultExtruderPosition", ExtruderManager.getDefaultExtruderPosition)
+
+    # Adds custom property types, settings types, and extra operators (functions) that need to be registered in
+    # SettingDefinition and SettingFunction.
+    def _initializeSettingFunctions(self):
+        self._cura_formula_functions = CuraFormulaFunctions(self)
+
+        SettingFunction.registerOperator("extruderValue", self._cura_formula_functions.getValueInExtruder)
+        SettingFunction.registerOperator("extruderValues", self._cura_formula_functions.getValuesInAllExtruders)
+        SettingFunction.registerOperator("resolveOrValue", self._cura_formula_functions.getResolveOrValue)
+        SettingFunction.registerOperator("defaultExtruderPosition", self._cura_formula_functions.getDefaultExtruderPosition)
 
     # Adds all resources and container related resources.
     def __addAllResourcesAndContainerResources(self) -> None:
@@ -368,7 +405,7 @@ class CuraApplication(QtApplication):
         # Add empty variant, material and quality containers.
         # Since they are empty, they should never be serialized and instead just programmatically created.
         # We need them to simplify the switching between materials.
-        self.empty_container = cura.Settings.cura_empty_instance_containers.empty_container
+        self.empty_container = cura.Settings.cura_empty_instance_containers.empty_container  # type: EmptyInstanceContainer
 
         self._container_registry.addContainer(
             cura.Settings.cura_empty_instance_containers.empty_definition_changes_container)
@@ -403,40 +440,39 @@ class CuraApplication(QtApplication):
         )
 
     # Runs preparations that needs to be done before the starting process.
-    def startSplashWindowPhase(self):
+    def startSplashWindowPhase(self) -> None:
         super().startSplashWindowPhase()
 
-        self.setWindowIcon(QIcon(Resources.getPath(Resources.Images, "cura-icon.png")))
+        if not self.getIsHeadLess():
+            self.setWindowIcon(QIcon(Resources.getPath(Resources.Images, "cura-icon.png")))
 
         self.setRequiredPlugins([
             # Misc.:
-            "ConsoleLogger",
-            "CuraEngineBackend",
-            "UserAgreement",
-            "FileLogger",
-            "XmlMaterialProfile",
-            "Toolbox",
-            "PrepareStage",
-            "MonitorStage",
-            "LocalFileOutputDevice",
-            "LocalContainerProvider",
+            "ConsoleLogger", #You want to be able to read the log if something goes wrong.
+            "CuraEngineBackend", #Cura is useless without this one since you can't slice.
+            "UserAgreement", #Our lawyers want every user to see this at least once.
+            "FileLogger", #You want to be able to read the log if something goes wrong.
+            "XmlMaterialProfile", #Cura crashes without this one.
+            "Toolbox", #This contains the interface to enable/disable plug-ins, so if you disable it you can't enable it back.
+            "PrepareStage", #Cura is useless without this one since you can't load models.
+            "PreviewStage", #This shows the list of the plugin views that are installed in Cura.
+            "MonitorStage", #Major part of Cura's functionality.
+            "LocalFileOutputDevice", #Major part of Cura's functionality.
+            "LocalContainerProvider", #Cura is useless without any profiles or setting definitions.
 
             # Views:
-            "SimpleView",
-            "SimulationView",
-            "SolidView",
+            "SimpleView", #Dependency of SolidView.
+            "SolidView", #Displays models. Cura is useless without it.
 
             # Readers & Writers:
-            "GCodeWriter",
-            "STLReader",
+            "GCodeWriter", #Cura is useless if it can't write its output.
+            "STLReader", #Most common model format, so disabling this makes Cura 90% useless.
+            "3MFWriter", #Required for writing project files.
 
             # Tools:
-            "CameraTool",
-            "MirrorTool",
-            "RotateTool",
-            "ScaleTool",
-            "SelectionTool",
-            "TranslateTool",
+            "CameraTool", #Needed to see the scene. Cura is useless without it.
+            "SelectionTool", #Dependency of the rest of the tools.
+            "TranslateTool", #You'll need this for almost every print.
         ])
         self._i18n_catalog = i18nCatalog("cura")
 
@@ -473,7 +509,8 @@ class CuraApplication(QtApplication):
         preferences.addPreference("cura/choice_on_profile_override", "always_ask")
         preferences.addPreference("cura/choice_on_open_project", "always_ask")
         preferences.addPreference("cura/use_multi_build_plate", False)
-
+        preferences.addPreference("view/settings_list_height", 400)
+        preferences.addPreference("view/settings_visible", False)
         preferences.addPreference("cura/currency", "€")
         preferences.addPreference("cura/material_settings", "{}")
 
@@ -481,7 +518,11 @@ class CuraApplication(QtApplication):
         preferences.addPreference("view/filter_current_build_plate", False)
         preferences.addPreference("cura/sidebar_collapsed", False)
 
-        self._need_to_show_user_agreement = not self.getPreferences().getValue("general/accepted_user_agreement")
+        preferences.addPreference("cura/favorite_materials", "")
+        preferences.addPreference("cura/expanded_brands", "")
+        preferences.addPreference("cura/expanded_types", "")
+
+        self._need_to_show_user_agreement = not preferences.getValue("general/accepted_user_agreement")
 
         for key in [
             "dialog_load_path",  # dialog_save_path is in LocalFileOutputDevicePlugin
@@ -495,26 +536,23 @@ class CuraApplication(QtApplication):
         self.applicationShuttingDown.connect(self.saveSettings)
         self.engineCreatedSignal.connect(self._onEngineCreated)
 
-        self.globalContainerStackChanged.connect(self._onGlobalContainerChanged)
-        self._onGlobalContainerChanged()
-
         self.getCuraSceneController().setActiveBuildPlate(0)  # Initialize
 
         CuraApplication.Created = True
 
     def _onEngineCreated(self):
-        self._qml_engine.addImageProvider("camera", CameraImageProvider.CameraImageProvider())
+        self._qml_engine.addImageProvider("print_job_preview", PrintJobPreviewImageProvider.PrintJobPreviewImageProvider())
 
     @pyqtProperty(bool)
-    def needToShowUserAgreement(self):
+    def needToShowUserAgreement(self) -> bool:
         return self._need_to_show_user_agreement
 
-    def setNeedToShowUserAgreement(self, set_value = True):
+    def setNeedToShowUserAgreement(self, set_value = True) -> None:
         self._need_to_show_user_agreement = set_value
 
     # DO NOT call this function to close the application, use checkAndExitApplication() instead which will perform
     # pre-exit checks such as checking for in-progress USB printing, etc.
-    def closeApplication(self):
+    def closeApplication(self) -> None:
         Logger.log("i", "Close application")
         main_window = self.getMainWindow()
         if main_window is not None:
@@ -541,11 +579,11 @@ class CuraApplication(QtApplication):
 
     showConfirmExitDialog = pyqtSignal(str, arguments = ["message"])
 
-    def setConfirmExitDialogCallback(self, callback):
+    def setConfirmExitDialogCallback(self, callback: Callable) -> None:
         self._confirm_exit_dialog_callback = callback
 
     @pyqtSlot(bool)
-    def callConfirmExitDialogCallback(self, yes_or_no: bool):
+    def callConfirmExitDialogCallback(self, yes_or_no: bool) -> None:
         self._confirm_exit_dialog_callback(yes_or_no)
 
     ##  Signal to connect preferences action in QML
@@ -553,9 +591,17 @@ class CuraApplication(QtApplication):
 
     ##  Show the preferences window
     @pyqtSlot()
-    def showPreferences(self):
+    def showPreferences(self) -> None:
         self.showPreferencesWindow.emit()
 
+    @override(Application)
+    def getGlobalContainerStack(self) -> Optional["GlobalStack"]:
+        return self._global_container_stack
+
+    @override(Application)
+    def setGlobalContainerStack(self, stack: "GlobalStack") -> None:
+        super().setGlobalContainerStack(stack)
+
     ## A reusable dialogbox
     #
     showMessageBox = pyqtSignal(str, str, str, str, int, int, arguments = ["title", "text", "informativeText", "detailedText", "buttons", "icon"])
@@ -567,7 +613,7 @@ class CuraApplication(QtApplication):
 
     showDiscardOrKeepProfileChanges = pyqtSignal()
 
-    def discardOrKeepProfileChanges(self):
+    def discardOrKeepProfileChanges(self) -> bool:
         has_user_interaction = False
         choice = self.getPreferences().getValue("cura/choice_on_profile_override")
         if choice == "always_discard":
@@ -583,7 +629,7 @@ class CuraApplication(QtApplication):
         return has_user_interaction
 
     @pyqtSlot(str)
-    def discardOrKeepProfileChangesClosed(self, option):
+    def discardOrKeepProfileChangesClosed(self, option: str) -> None:
         global_stack = self.getGlobalContainerStack()
         if option == "discard":
             for extruder in global_stack.extruders.values():
@@ -603,9 +649,7 @@ class CuraApplication(QtApplication):
             self._message_box_callback(button, *self._message_box_callback_arguments)
             self._message_box_callback = None
             self._message_box_callback_arguments = []
-
-    showPrintMonitor = pyqtSignal(bool, arguments = ["show"])
-
+            
     def setSaveDataEnabled(self, enabled: bool) -> None:
         self._save_data_enabled = enabled
 
@@ -631,12 +675,12 @@ class CuraApplication(QtApplication):
 
     ##  Handle loading of all plugin types (and the backend explicitly)
     #   \sa PluginRegistry
-    def _loadPlugins(self):
+    def _loadPlugins(self) -> None:
         self._plugin_registry.addType("profile_reader", self._addProfileReader)
         self._plugin_registry.addType("profile_writer", self._addProfileWriter)
 
         if Platform.isLinux():
-            lib_suffixes = {"", "64", "32", "x32"} #A few common ones on different distributions.
+            lib_suffixes = {"", "64", "32", "x32"}  # A few common ones on different distributions.
         else:
             lib_suffixes = {""}
         for suffix in lib_suffixes:
@@ -668,11 +712,11 @@ class CuraApplication(QtApplication):
 
         Logger.log("i", "Initializing quality manager")
         from cura.Machines.QualityManager import QualityManager
-        self._quality_manager = QualityManager(container_registry, parent = self)
+        self._quality_manager = QualityManager(self, parent = self)
         self._quality_manager.initialize()
 
         Logger.log("i", "Initializing machine manager")
-        self._machine_manager = MachineManager(self)
+        self._machine_manager = MachineManager(self, parent = self)
 
         Logger.log("i", "Initializing container manager")
         self._container_manager = ContainerManager(self)
@@ -695,10 +739,11 @@ class CuraApplication(QtApplication):
         self._print_information = PrintInformation.PrintInformation(self)
         self._cura_actions = CuraActions.CuraActions(self)
 
-        # Initialize setting visibility presets model
-        self._setting_visibility_presets_model = SettingVisibilityPresetsModel(self)
-        default_visibility_profile = self._setting_visibility_presets_model.getItem(0)
-        self.getPreferences().setDefault("general/visible_settings", ";".join(default_visibility_profile["settings"]))
+        # Initialize setting visibility presets model.
+        self._setting_visibility_presets_model = SettingVisibilityPresetsModel(self.getPreferences(), parent = self)
+
+        # Initialize Cura API
+        self._cura_API.initialize()
 
         # Detect in which mode to run and execute that mode
         if self._is_headless:
@@ -798,6 +843,11 @@ class CuraApplication(QtApplication):
     def getSettingVisibilityPresetsModel(self, *args) -> SettingVisibilityPresetsModel:
         return self._setting_visibility_presets_model
 
+    def getCuraFormulaFunctions(self, *args) -> "CuraFormulaFunctions":
+        if self._cura_formula_functions is None:
+            self._cura_formula_functions = CuraFormulaFunctions(self)
+        return self._cura_formula_functions
+
     def getMachineErrorChecker(self, *args) -> MachineErrorChecker:
         return self._machine_error_checker
 
@@ -806,20 +856,20 @@ class CuraApplication(QtApplication):
             self._machine_manager = MachineManager(self)
         return self._machine_manager
 
-    def getExtruderManager(self, *args):
+    def getExtruderManager(self, *args) -> ExtruderManager:
         if self._extruder_manager is None:
             self._extruder_manager = ExtruderManager()
         return self._extruder_manager
 
-    def getVariantManager(self, *args):
+    def getVariantManager(self, *args) -> VariantManager:
         return self._variant_manager
 
     @pyqtSlot(result = QObject)
-    def getMaterialManager(self, *args):
+    def getMaterialManager(self, *args) -> "MaterialManager":
         return self._material_manager
 
     @pyqtSlot(result = QObject)
-    def getQualityManager(self, *args):
+    def getQualityManager(self, *args) -> "QualityManager":
         return self._quality_manager
 
     def getObjectsModel(self, *args):
@@ -828,23 +878,36 @@ class CuraApplication(QtApplication):
         return self._object_manager
 
     @pyqtSlot(result = QObject)
-    def getMultiBuildPlateModel(self, *args):
+    def getExtrudersModel(self, *args) -> "ExtrudersModel":
+        if self._extruders_model is None:
+            self._extruders_model = ExtrudersModel(self)
+        return self._extruders_model
+
+    @pyqtSlot(result = QObject)
+    def getExtrudersModelWithOptional(self, *args) -> "ExtrudersModel":
+        if self._extruders_model_with_optional is None:
+            self._extruders_model_with_optional = ExtrudersModel(self)
+            self._extruders_model_with_optional.setAddOptionalExtruder(True)
+        return self._extruders_model_with_optional
+
+    @pyqtSlot(result = QObject)
+    def getMultiBuildPlateModel(self, *args) -> MultiBuildPlateModel:
         if self._multi_build_plate_model is None:
             self._multi_build_plate_model = MultiBuildPlateModel(self)
         return self._multi_build_plate_model
 
     @pyqtSlot(result = QObject)
-    def getBuildPlateModel(self, *args):
+    def getBuildPlateModel(self, *args) -> BuildPlateModel:
         if self._build_plate_model is None:
             self._build_plate_model = BuildPlateModel(self)
         return self._build_plate_model
 
-    def getCuraSceneController(self, *args):
+    def getCuraSceneController(self, *args) -> CuraSceneController:
         if self._cura_scene_controller is None:
             self._cura_scene_controller = CuraSceneController.createCuraSceneController()
         return self._cura_scene_controller
 
-    def getSettingInheritanceManager(self, *args):
+    def getSettingInheritanceManager(self, *args) -> SettingInheritanceManager:
         if self._setting_inheritance_manager is None:
             self._setting_inheritance_manager = SettingInheritanceManager.createSettingInheritanceManager()
         return self._setting_inheritance_manager
@@ -887,6 +950,9 @@ class CuraApplication(QtApplication):
             self._custom_quality_profile_drop_down_menu_model = CustomQualityProfilesDropDownMenuModel(self)
         return self._custom_quality_profile_drop_down_menu_model
 
+    def getCuraAPI(self, *args, **kwargs) -> "CuraAPI":
+        return self._cura_API
+
     ##  Registers objects for the QML engine to use.
     #
     #   \param engine The QML engine.
@@ -898,7 +964,7 @@ class CuraApplication(QtApplication):
         engine.rootContext().setContextProperty("CuraApplication", self)
         engine.rootContext().setContextProperty("PrintInformation", self._print_information)
         engine.rootContext().setContextProperty("CuraActions", self._cura_actions)
-        engine.rootContext().setContextProperty("CuraSDKVersion", CuraSDKVersion)
+        engine.rootContext().setContextProperty("CuraSDKVersion", ApplicationMetadata.CuraSDKVersion)
 
         qmlRegisterUncreatableType(CuraApplication, "Cura", 1, 0, "ResourceTypes", "Just an Enum type")
 
@@ -909,15 +975,18 @@ class CuraApplication(QtApplication):
         qmlRegisterSingletonType(SimpleModeSettingsManager, "Cura", 1, 0, "SimpleModeSettingsManager", self.getSimpleModeSettingsManager)
         qmlRegisterSingletonType(MachineActionManager.MachineActionManager, "Cura", 1, 0, "MachineActionManager", self.getMachineActionManager)
 
+        qmlRegisterType(NetworkMJPGImage, "Cura", 1, 0, "NetworkMJPGImage")
+
         qmlRegisterSingletonType(ObjectsModel, "Cura", 1, 0, "ObjectsModel", self.getObjectsModel)
         qmlRegisterType(BuildPlateModel, "Cura", 1, 0, "BuildPlateModel")
         qmlRegisterType(MultiBuildPlateModel, "Cura", 1, 0, "MultiBuildPlateModel")
         qmlRegisterType(InstanceContainer, "Cura", 1, 0, "InstanceContainer")
         qmlRegisterType(ExtrudersModel, "Cura", 1, 0, "ExtrudersModel")
+        qmlRegisterType(GlobalStacksModel, "Cura", 1, 0, "GlobalStacksModel")
 
+        qmlRegisterType(FavoriteMaterialsModel, "Cura", 1, 0, "FavoriteMaterialsModel")
         qmlRegisterType(GenericMaterialsModel, "Cura", 1, 0, "GenericMaterialsModel")
-        qmlRegisterType(BrandMaterialsModel, "Cura", 1, 0, "BrandMaterialsModel")
-        qmlRegisterType(MaterialManagementModel, "Cura", 1, 0, "MaterialManagementModel")
+        qmlRegisterType(MaterialBrandsModel, "Cura", 1, 0, "MaterialBrandsModel")
         qmlRegisterType(QualityManagementModel, "Cura", 1, 0, "QualityManagementModel")
         qmlRegisterType(MachineManagementModel, "Cura", 1, 0, "MachineManagementModel")
 
@@ -935,6 +1004,11 @@ class CuraApplication(QtApplication):
         qmlRegisterSingletonType(ContainerManager, "Cura", 1, 0, "ContainerManager", ContainerManager.getInstance)
         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)
+
         # 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")))
         qmlRegisterSingletonType(actions_url, "Cura", 1, 0, "Actions")
@@ -981,30 +1055,14 @@ class CuraApplication(QtApplication):
             self._camera_animation.setTarget(Selection.getSelectedObject(0).getWorldPosition())
             self._camera_animation.start()
 
-    def _onGlobalContainerChanged(self):
-        if self._global_container_stack is not None:
-            machine_file_formats = [file_type.strip() for file_type in self._global_container_stack.getMetaDataEntry("file_formats").split(";")]
-            new_preferred_mimetype = ""
-            if machine_file_formats:
-                new_preferred_mimetype =  machine_file_formats[0]
-
-            if new_preferred_mimetype != self._preferred_mimetype:
-                self._preferred_mimetype = new_preferred_mimetype
-                self.preferredOutputMimetypeChanged.emit()
-
     requestAddPrinter = pyqtSignal()
     activityChanged = pyqtSignal()
     sceneBoundingBoxChanged = pyqtSignal()
-    preferredOutputMimetypeChanged = pyqtSignal()
 
     @pyqtProperty(bool, notify = activityChanged)
     def platformActivity(self):
         return self._platform_activity
 
-    @pyqtProperty(str, notify=preferredOutputMimetypeChanged)
-    def preferredOutputMimetype(self):
-        return self._preferred_mimetype
-
     @pyqtProperty(str, notify = sceneBoundingBoxChanged)
     def getSceneBoundingBoxString(self):
         return self._i18n_catalog.i18nc("@info 'width', 'depth' and 'height' are variable names that must NOT be translated; just translate the format of ##x##x## mm.", "%(width).1f x %(depth).1f x %(height).1f mm") % {'width' : self._scene_bounding_box.width.item(), 'depth': self._scene_bounding_box.depth.item(), 'height' : self._scene_bounding_box.height.item()}
@@ -1058,88 +1116,6 @@ class CuraApplication(QtApplication):
         self._platform_activity = True if count > 0 else False
         self.activityChanged.emit()
 
-    # Remove all selected objects from the scene.
-    @pyqtSlot()
-    @deprecated("Moved to CuraActions", "2.6")
-    def deleteSelection(self):
-        if not self.getController().getToolsEnabled():
-            return
-        removed_group_nodes = []
-        op = GroupedOperation()
-        nodes = Selection.getAllSelectedObjects()
-        for node in nodes:
-            op.addOperation(RemoveSceneNodeOperation(node))
-            group_node = node.getParent()
-            if group_node and group_node.callDecoration("isGroup") and group_node not in removed_group_nodes:
-                remaining_nodes_in_group = list(set(group_node.getChildren()) - set(nodes))
-                if len(remaining_nodes_in_group) == 1:
-                    removed_group_nodes.append(group_node)
-                    op.addOperation(SetParentOperation(remaining_nodes_in_group[0], group_node.getParent()))
-                    op.addOperation(RemoveSceneNodeOperation(group_node))
-        op.push()
-
-    ##  Remove an object from the scene.
-    #   Note that this only removes an object if it is selected.
-    @pyqtSlot("quint64")
-    @deprecated("Use deleteSelection instead", "2.6")
-    def deleteObject(self, object_id):
-        if not self.getController().getToolsEnabled():
-            return
-
-        node = self.getController().getScene().findObject(object_id)
-
-        if not node and object_id != 0:  # Workaround for tool handles overlapping the selected object
-            node = Selection.getSelectedObject(0)
-
-        if node:
-            op = GroupedOperation()
-            op.addOperation(RemoveSceneNodeOperation(node))
-
-            group_node = node.getParent()
-            if group_node:
-                # Note that at this point the node has not yet been deleted
-                if len(group_node.getChildren()) <= 2 and group_node.callDecoration("isGroup"):
-                    op.addOperation(SetParentOperation(group_node.getChildren()[0], group_node.getParent()))
-                    op.addOperation(RemoveSceneNodeOperation(group_node))
-
-            op.push()
-
-    ##  Create a number of copies of existing object.
-    #   \param object_id
-    #   \param count number of copies
-    #   \param min_offset minimum offset to other objects.
-    @pyqtSlot("quint64", int)
-    @deprecated("Use CuraActions::multiplySelection", "2.6")
-    def multiplyObject(self, object_id, count, min_offset = 8):
-        node = self.getController().getScene().findObject(object_id)
-        if not node:
-            node = Selection.getSelectedObject(0)
-
-        while node.getParent() and node.getParent().callDecoration("isGroup"):
-            node = node.getParent()
-
-        job = MultiplyObjectsJob([node], count, min_offset)
-        job.start()
-        return
-
-    ##  Center object on platform.
-    @pyqtSlot("quint64")
-    @deprecated("Use CuraActions::centerSelection", "2.6")
-    def centerObject(self, object_id):
-        node = self.getController().getScene().findObject(object_id)
-        if not node and object_id != 0:  # Workaround for tool handles overlapping the selected object
-            node = Selection.getSelectedObject(0)
-
-        if not node:
-            return
-
-        if node.getParent() and node.getParent().callDecoration("isGroup"):
-            node = node.getParent()
-
-        if node:
-            op = SetTransformOperation(node, Vector())
-            op.push()
-
     ##  Select all nodes containing mesh data in the scene.
     @pyqtSlot()
     def selectAll(self):
@@ -1219,62 +1195,75 @@ class CuraApplication(QtApplication):
 
     ##  Arrange all objects.
     @pyqtSlot()
-    def arrangeObjectsToAllBuildPlates(self):
-        nodes = []
-        for node in DepthFirstIterator(self.getController().getScene().getRoot()):
+    def arrangeObjectsToAllBuildPlates(self) -> None:
+        nodes_to_arrange = []
+        for node in DepthFirstIterator(self.getController().getScene().getRoot()):  # type: ignore
             if not isinstance(node, SceneNode):
                 continue
+
             if not node.getMeshData() and not node.callDecoration("isGroup"):
                 continue  # Node that doesnt have a mesh and is not a group.
-            if node.getParent() and node.getParent().callDecoration("isGroup"):
-                continue  # Grouped nodes don't need resetting as their parent (the group) is resetted)
+
+            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 node.getBoundingBox().width < self._volume.getBoundingBox().width or node.getBoundingBox().depth < self._volume.getBoundingBox().depth:
-                nodes.append(node)
-        job = ArrangeObjectsAllBuildPlatesJob(nodes)
+            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):
-        nodes = []
+    def arrangeAll(self) -> None:
+        nodes_to_arrange = []
         active_build_plate = self.getMultiBuildPlateModel().activeBuildPlate
-        for node in DepthFirstIterator(self.getController().getScene().getRoot()):
+        for node in DepthFirstIterator(self.getController().getScene().getRoot()):  # type: ignore
             if not isinstance(node, SceneNode):
                 continue
+
             if not node.getMeshData() and not node.callDecoration("isGroup"):
                 continue  # Node that doesnt have a mesh and is not a group.
-            if node.getParent() and node.getParent().callDecoration("isGroup"):
+
+            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 resetted)
+
             if not node.isSelectable():
                 continue  # i.e. node with layer data
+
             if not node.callDecoration("isSliceable") and not node.callDecoration("isGroup"):
                 continue  # i.e. node with layer data
+
             if node.callDecoration("getBuildPlateNumber") == active_build_plate:
                 # Skip nodes that are too big
-                if node.getBoundingBox().width < self._volume.getBoundingBox().width or node.getBoundingBox().depth < self._volume.getBoundingBox().depth:
-                    nodes.append(node)
-        self.arrange(nodes, fixed_nodes = [])
+                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:
+                    nodes_to_arrange.append(node)
+        self.arrange(nodes_to_arrange, fixed_nodes = [])
 
     ##  Arrange a set of nodes given a set of fixed nodes
     #   \param nodes nodes that we have to place
     #   \param fixed_nodes nodes that are placed in the arranger before finding spots for nodes
-    def arrange(self, nodes, fixed_nodes):
+    def arrange(self, nodes: List[SceneNode], fixed_nodes: List[SceneNode]) -> None:
         min_offset = self.getBuildVolume().getEdgeDisallowedSize() + 2  # Allow for some rounding errors
         job = ArrangeObjectsJob(nodes, fixed_nodes, min_offset = max(min_offset, 8))
         job.start()
 
     ##  Reload all mesh data on the screen from file.
     @pyqtSlot()
-    def reloadAll(self):
+    def reloadAll(self) -> None:
         Logger.log("i", "Reloading all loaded mesh data.")
         nodes = []
         has_merged_nodes = False
-        for node in DepthFirstIterator(self.getController().getScene().getRoot()):
-            if not isinstance(node, CuraSceneNode) or not node.getMeshData() :
+        for node in DepthFirstIterator(self.getController().getScene().getRoot()):  # type: ignore
+            if not isinstance(node, CuraSceneNode) or not node.getMeshData():
                 if node.getName() == "MergedMesh":
                     has_merged_nodes = True
                 continue
@@ -1288,7 +1277,7 @@ class CuraApplication(QtApplication):
             file_name = node.getMeshData().getFileName()
             if file_name:
                 job = ReadMeshJob(file_name)
-                job._node = node
+                job._node = node  # type: ignore
                 job.finished.connect(self._reloadMeshFinished)
                 if has_merged_nodes:
                     job.finished.connect(self.updateOriginOfMergedMeshes)
@@ -1297,20 +1286,8 @@ class CuraApplication(QtApplication):
             else:
                 Logger.log("w", "Unable to reload data because we don't have a filename.")
 
-
-    ##  Get logging data of the backend engine
-    #   \returns \type{string} Logging data
-    @pyqtSlot(result = str)
-    def getEngineLog(self):
-        log = ""
-
-        for entry in self.getBackend().getLog():
-            log += entry.decode()
-
-        return log
-
     @pyqtSlot("QStringList")
-    def setExpandedCategories(self, categories):
+    def setExpandedCategories(self, categories: List[str]) -> None:
         categories = list(set(categories))
         categories.sort()
         joined = ";".join(categories)
@@ -1321,7 +1298,7 @@ class CuraApplication(QtApplication):
     expandedCategoriesChanged = pyqtSignal()
 
     @pyqtProperty("QStringList", notify = expandedCategoriesChanged)
-    def expandedCategories(self):
+    def expandedCategories(self) -> List[str]:
         return self.getPreferences().getValue("cura/categories_expanded").split(";")
 
     @pyqtSlot()
@@ -1371,13 +1348,12 @@ class CuraApplication(QtApplication):
 
 
     ##  Updates origin position of all merged meshes
-    #   \param jobNode \type{Job} empty object which passed which is required by JobQueue
-    def updateOriginOfMergedMeshes(self, jobNode):
+    def updateOriginOfMergedMeshes(self, _):
         group_nodes = []
         for node in DepthFirstIterator(self.getController().getScene().getRoot()):
             if isinstance(node, CuraSceneNode) and node.getName() == "MergedMesh":
 
-                #checking by name might be not enough, the merged mesh should has "GroupDecorator" decorator
+                # Checking by name might be not enough, the merged mesh should has "GroupDecorator" decorator
                 for decorator in node.getDecorators():
                     if isinstance(decorator, GroupDecorator):
                         group_nodes.append(node)
@@ -1421,7 +1397,7 @@ class CuraApplication(QtApplication):
 
 
     @pyqtSlot()
-    def groupSelected(self):
+    def groupSelected(self) -> None:
         # Create a group-node
         group_node = CuraSceneNode()
         group_decorator = GroupDecorator()
@@ -1437,7 +1413,8 @@ class CuraApplication(QtApplication):
         # Remove nodes that are directly parented to another selected node from the selection so they remain parented
         selected_nodes = Selection.getAllSelectedObjects().copy()
         for node in selected_nodes:
-            if node.getParent() in selected_nodes and not node.getParent().callDecoration("isGroup"):
+            parent = node.getParent()
+            if parent is not None and parent in selected_nodes and not parent.callDecoration("isGroup"):
                 Selection.remove(node)
 
         # Move selected nodes into the group-node
@@ -1449,7 +1426,7 @@ class CuraApplication(QtApplication):
         Selection.add(group_node)
 
     @pyqtSlot()
-    def ungroupSelected(self):
+    def ungroupSelected(self) -> None:
         selected_objects = Selection.getAllSelectedObjects().copy()
         for node in selected_objects:
             if node.callDecoration("isGroup"):
@@ -1472,7 +1449,7 @@ class CuraApplication(QtApplication):
                 # Note: The group removes itself from the scene once all its children have left it,
                 # see GroupDecorator._onChildrenChanged
 
-    def _createSplashScreen(self):
+    def _createSplashScreen(self) -> Optional[CuraSplashScreen.CuraSplashScreen]:
         if self._is_headless:
             return None
         return CuraSplashScreen.CuraSplashScreen()
@@ -1590,6 +1567,11 @@ class CuraApplication(QtApplication):
         job.start()
 
     def _readMeshFinished(self, job):
+        global_container_stack = self.getGlobalContainerStack()
+        if not global_container_stack:
+            Logger.log("w", "Can't load meshes before a printer is added.")
+            return
+
         nodes = job.getResult()
         file_name = job.getFileName()
         file_name_lower = file_name.lower()
@@ -1604,7 +1586,6 @@ class CuraApplication(QtApplication):
         for node_ in DepthFirstIterator(root):
             if node_.callDecoration("isSliceable") and node_.callDecoration("getBuildPlateNumber") == target_build_plate:
                 fixed_nodes.append(node_)
-        global_container_stack = self.getGlobalContainerStack()
         machine_width = global_container_stack.getProperty("machine_width", "value")
         machine_depth = global_container_stack.getProperty("machine_depth", "value")
         arranger = Arrange.create(x = machine_width, y = machine_depth, fixed_nodes = fixed_nodes)
@@ -1634,7 +1615,9 @@ class CuraApplication(QtApplication):
             is_non_sliceable = "." + file_extension in self._non_sliceable_extensions
 
             if is_non_sliceable:
-                self.callLater(lambda: self.getController().setActiveView("SimulationView"))
+                # Need to switch first to the preview stage and then to layer view
+                self.callLater(lambda: (self.getController().setActiveStage("PreviewStage"),
+                                        self.getController().setActiveView("SimulationView")))
 
                 block_slicing_decorator = BlockSlicingDecorator()
                 node.addDecorator(block_slicing_decorator)
@@ -1720,7 +1703,11 @@ class CuraApplication(QtApplication):
 
     @pyqtSlot()
     def showMoreInformationDialogForAnonymousDataCollection(self):
-        cast(SliceInfo, self._plugin_registry.getPluginObject("SliceInfoPlugin")).showMoreInfoDialog()
+        try:
+            slice_info = self._plugin_registry.getPluginObject("SliceInfoPlugin")
+            slice_info.showMoreInfoDialog()
+        except PluginNotFoundError:
+            Logger.log("w", "Plugin SliceInfo was not found, so not able to show the info dialog.")
 
     def addSidebarCustomMenuItem(self, menu_item: dict) -> None:
         self._sidebar_custom_menu_items.append(menu_item)

cura/CuraVersion.py.in

@@ -1,9 +1,12 @@
-# Copyright (c) 2015 Ultimaker B.V.
+# Copyright (c) 2018 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
 CuraSDKVersion = "@CURA_SDK_VERSION@"
 CuraCloudAPIRoot = "@CURA_CLOUD_API_ROOT@"
 CuraCloudAPIVersion = "@CURA_CLOUD_API_VERSION@"
+CuraCloudAccountAPIRoot = "@CURA_CLOUD_ACCOUNT_API_ROOT@"

cura/CuraView.py

@@ -0,0 +1,24 @@
+# Copyright (c) 2018 Ultimaker B.V.
+# Cura is released under the terms of the LGPLv3 or higher.
+
+from PyQt5.QtCore import pyqtProperty, QUrl
+
+from UM.View.View import View
+
+
+# Since Cura has a few pre-defined "space claims" for the locations of certain components, we've provided some structure
+# to indicate this.
+#   MainComponent works in the same way the MainComponent of a stage.
+#   the stageMenuComponent returns an item that should be used somehwere in the stage menu. It's up to the active stage
+#   to actually do something with this.
+class CuraView(View):
+    def __init__(self, parent = None) -> None:
+        super().__init__(parent)
+
+    @pyqtProperty(QUrl, constant = True)
+    def mainComponent(self) -> QUrl:
+        return self.getDisplayComponent("main")
+
+    @pyqtProperty(QUrl, constant = True)
+    def stageMenuComponent(self) -> QUrl:
+        return self.getDisplayComponent("menu")

cura/GlobalStacksModel.py

@@ -0,0 +1,70 @@
+# Copyright (c) 2018 Ultimaker B.V.
+# Cura is released under the terms of the LGPLv3 or higher.
+
+
+from UM.Qt.ListModel import ListModel
+
+from PyQt5.QtCore import pyqtProperty, Qt, QTimer
+
+from cura.PrinterOutputDevice import ConnectionType
+from cura.Settings.CuraContainerRegistry import CuraContainerRegistry
+
+from cura.Settings.GlobalStack import GlobalStack
+
+
+class GlobalStacksModel(ListModel):
+    NameRole = Qt.UserRole + 1
+    IdRole = Qt.UserRole + 2
+    HasRemoteConnectionRole = Qt.UserRole + 3
+    ConnectionTypeRole = Qt.UserRole + 4
+    MetaDataRole = Qt.UserRole + 5
+
+    def __init__(self, parent = None):
+        super().__init__(parent)
+        self.addRoleName(self.NameRole, "name")
+        self.addRoleName(self.IdRole, "id")
+        self.addRoleName(self.HasRemoteConnectionRole, "hasRemoteConnection")
+        self.addRoleName(self.MetaDataRole, "metadata")
+        self._container_stacks = []
+
+        self._change_timer = QTimer()
+        self._change_timer.setInterval(200)
+        self._change_timer.setSingleShot(True)
+        self._change_timer.timeout.connect(self._update)
+
+        # Listen to changes
+        CuraContainerRegistry.getInstance().containerAdded.connect(self._onContainerChanged)
+        CuraContainerRegistry.getInstance().containerMetaDataChanged.connect(self._onContainerChanged)
+        CuraContainerRegistry.getInstance().containerRemoved.connect(self._onContainerChanged)
+        self._filter_dict = {}
+        self._updateDelayed()
+
+    ##  Handler for container added/removed events from registry
+    def _onContainerChanged(self, container):
+        # We only need to update when the added / removed container GlobalStack
+        if isinstance(container, GlobalStack):
+            self._updateDelayed()
+
+    def _updateDelayed(self):
+        self._change_timer.start()
+
+    def _update(self) -> None:
+        items = []
+
+        container_stacks = CuraContainerRegistry.getInstance().findContainerStacks(type = "machine")
+
+        for container_stack in container_stacks:
+            has_remote_connection = False
+
+            for connection_type in container_stack.configuredConnectionTypes:
+                has_remote_connection |= connection_type in [ConnectionType.NetworkConnection.value, ConnectionType.CloudConnection.value]
+
+            if container_stack.getMetaDataEntry("hidden", False) in ["True", True]:
+                continue
+
+            items.append({"name": container_stack.getMetaDataEntry("group_name", container_stack.getName()),
+                          "id": container_stack.getId(),
+                          "hasRemoteConnection": has_remote_connection,
+                          "metadata": container_stack.getMetaData().copy()})
+        items.sort(key=lambda i: not i["hasRemoteConnection"])
+        self.setItems(items)

cura/LayerDataBuilder.py

@@ -7,43 +7,36 @@ from UM.Mesh.MeshBuilder import MeshBuilder
 from .LayerData import LayerData
 
 import numpy
+from typing import Dict, Optional
 
 
 ## Builder class for constructing a LayerData object
 class LayerDataBuilder(MeshBuilder):
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__()
-        self._layers = {}
-        self._element_counts = {}
+        self._layers = {}  # type: Dict[int, Layer]
+        self._element_counts = {}  # type: Dict[int, int]
 
-    def addLayer(self, layer):
+    def addLayer(self, layer: int) -> None:
         if layer not in self._layers:
             self._layers[layer] = Layer(layer)
 
-    def addPolygon(self, layer, polygon_type, data, line_width, line_thickness, line_feedrate):
-        if layer not in self._layers:
-            self.addLayer(layer)
+    def getLayer(self, layer: int) -> Optional[Layer]:
+        return self._layers.get(layer)
 
-        p = LayerPolygon(self, polygon_type, data, line_width, line_thickness, line_feedrate)
-        self._layers[layer].polygons.append(p)
-
-    def getLayer(self, layer):
-        if layer in self._layers:
-            return self._layers[layer]
-
-    def getLayers(self):
+    def getLayers(self) -> Dict[int, Layer]:
         return self._layers
 
-    def getElementCounts(self):
+    def getElementCounts(self) -> Dict[int, int]:
         return self._element_counts
 
-    def setLayerHeight(self, layer, height):
+    def setLayerHeight(self, layer: int, height: float) -> None:
         if layer not in self._layers:
             self.addLayer(layer)
 
         self._layers[layer].setHeight(height)
 
-    def setLayerThickness(self, layer, thickness):
+    def setLayerThickness(self, layer: int, thickness: float) -> None:
         if layer not in self._layers:
             self.addLayer(layer)
 
@@ -71,7 +64,7 @@ class LayerDataBuilder(MeshBuilder):
         vertex_offset = 0
         index_offset = 0
         for layer, data in sorted(self._layers.items()):
-            ( vertex_offset, index_offset ) = data.build( vertex_offset, index_offset, vertices, colors, line_dimensions, feedrates, extruders, line_types, indices)
+            vertex_offset, index_offset = data.build(vertex_offset, index_offset, vertices, colors, line_dimensions, feedrates, extruders, line_types, indices)
             self._element_counts[layer] = data.elementCount
 
         self.addVertices(vertices)

cura/LayerDataDecorator.py

@@ -1,13 +1,25 @@
+# Copyright (c) 2019 Ultimaker B.V.
+# Cura is released under the terms of the LGPLv3 or higher.
+
+from typing import Optional
 from UM.Scene.SceneNodeDecorator import SceneNodeDecorator
 
+from cura.LayerData import LayerData
+
+
 ## Simple decorator to indicate a scene node holds layer data.
 class LayerDataDecorator(SceneNodeDecorator):
     def __init__(self):
         super().__init__()
-        self._layer_data = None
-        
-    def getLayerData(self):
+        self._layer_data = None  # type: Optional[LayerData]
+
+    def getLayerData(self) -> Optional["LayerData"]:
         return self._layer_data
-    
-    def setLayerData(self, layer_data):
-        self._layer_data = layer_data
+
+    def setLayerData(self, layer_data: LayerData) -> None:
+        self._layer_data = layer_data
+
+    def __deepcopy__(self, memo) -> "LayerDataDecorator":
+        copied_decorator = LayerDataDecorator()
+        copied_decorator._layer_data = self._layer_data
+        return copied_decorator

cura/LayerPolygon.py

@@ -2,9 +2,11 @@
 # Cura is released under the terms of the LGPLv3 or higher.
 
 from UM.Application import Application
-from typing import Any
+from typing import Any, Optional
 import numpy
 
+from UM.Logger import Logger
+
 
 class LayerPolygon:
     NoneType = 0
@@ -18,22 +20,24 @@ class LayerPolygon:
     MoveCombingType = 8
     MoveRetractionType = 9
     SupportInterfaceType = 10
-    __number_of_types = 11
+    PrimeTower = 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)
-    
+
     ##  LayerPolygon, used in ProcessSlicedLayersJob
-    #   \param extruder
+    #   \param extruder The position of the extruder
     #   \param line_types array with line_types
     #   \param data new_points
     #   \param line_widths array with line widths
     #   \param line_thicknesses: array with type as index and thickness as value
     #   \param line_feedrates array with line feedrates
-    def __init__(self, extruder, line_types, data, line_widths, line_thicknesses, line_feedrates):
+    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:
         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.
+            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
         self._data = data
         self._line_widths = line_widths
@@ -53,16 +57,16 @@ class LayerPolygon:
         # Buffering the colors shouldn't be necessary as it is not 
         # re-used and can save alot of memory usage.
         self._color_map = LayerPolygon.getColorMap()
-        self._colors = self._color_map[self._types]
+        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
         # Should be generated in better way, not hardcoded.
         self._isInfillOrSkinTypeMap = numpy.array([0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1], dtype=numpy.bool)
         
-        self._build_cache_line_mesh_mask = None
-        self._build_cache_needed_points = None
+        self._build_cache_line_mesh_mask = None  # type: Optional[numpy.ndarray]
+        self._build_cache_needed_points = None  # type: Optional[numpy.ndarray]
         
-    def buildCache(self):
+    def buildCache(self) -> None:
         # For the line mesh we do not draw Infill or Jumps. Therefore those lines are filtered out.
         self._build_cache_line_mesh_mask = numpy.ones(self._jump_mask.shape, dtype=bool)
         mesh_line_count = numpy.sum(self._build_cache_line_mesh_mask)
@@ -90,10 +94,14 @@ class LayerPolygon:
     #   \param extruders : vertex numpy array to be filled
     #   \param line_types : vertex numpy array to be filled
     #   \param indices : index numpy array to be filled
-    def build(self, vertex_offset, index_offset, vertices, colors, line_dimensions, feedrates, extruders, line_types, indices):
+    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:
         if self._build_cache_line_mesh_mask is None or self._build_cache_needed_points is None:
             self.buildCache()
-            
+
+        if self._build_cache_line_mesh_mask is None or self._build_cache_needed_points is None:
+            Logger.log("w", "Failed to build cache for layer polygon")
+            return
+
         line_mesh_mask = self._build_cache_line_mesh_mask
         needed_points_list = self._build_cache_needed_points
         
@@ -236,7 +244,8 @@ class LayerPolygon:
                 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_support_interface").getRgbF(),  # SupportInterfaceType
+                theme.getColor("layerview_prime_tower").getRgbF()
             ])
 
         return cls.__color_map

cura/MachineAction.py

@@ -1,13 +1,13 @@
 # Copyright (c) 2016 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
 
+import os
+
 from PyQt5.QtCore import QObject, pyqtSlot, pyqtProperty, pyqtSignal
 
+from UM.Logger import Logger
 from UM.PluginObject import PluginObject
 from UM.PluginRegistry import PluginRegistry
-from UM.Application import Application
-
-import os
 
 
 ##  Machine actions are actions that are added to a specific machine type. Examples of such actions are
@@ -19,7 +19,7 @@ class MachineAction(QObject, PluginObject):
     ##  Create a new Machine action.
     #   \param key unique key of the machine action
     #   \param label Human readable label used to identify the machine action.
-    def __init__(self, key, label = ""):
+    def __init__(self, key: str, label: str = "") -> None:
         super().__init__()
         self._key = key
         self._label = label
@@ -30,14 +30,14 @@ class MachineAction(QObject, PluginObject):
     labelChanged = pyqtSignal()
     onFinished = pyqtSignal()
 
-    def getKey(self):
+    def getKey(self) -> str:
         return self._key
 
     @pyqtProperty(str, notify = labelChanged)
-    def label(self):
+    def label(self) -> str:
         return self._label
 
-    def setLabel(self, label):
+    def setLabel(self, label: str) -> None:
         if self._label != label:
             self._label = label
             self.labelChanged.emit()
@@ -46,29 +46,35 @@ class MachineAction(QObject, PluginObject):
     #   This should not be re-implemented by child classes, instead re-implement _reset.
     #   /sa _reset
     @pyqtSlot()
-    def reset(self):
+    def reset(self) -> None:
         self._finished = False
         self._reset()
 
     ##  Protected implementation of reset.
     #   /sa reset()
-    def _reset(self):
+    def _reset(self) -> None:
         pass
 
     @pyqtSlot()
-    def setFinished(self):
+    def setFinished(self) -> None:
         self._finished = True
         self._reset()
         self.onFinished.emit()
 
     @pyqtProperty(bool, notify = onFinished)
-    def finished(self):
+    def finished(self) -> bool:
         return self._finished
 
     ##  Protected helper to create a view object based on provided QML.
-    def _createViewFromQML(self):
-        path = os.path.join(PluginRegistry.getInstance().getPluginPath(self.getPluginId()), self._qml_url)
-        self._view = Application.getInstance().createQmlComponent(path, {"manager": self})
+    def _createViewFromQML(self) -> None:
+        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())
+            return
+        path = os.path.join(plugin_path, self._qml_url)
+
+        from cura.CuraApplication import CuraApplication
+        self._view = CuraApplication.getInstance().createQmlComponent(path, {"manager": self})
 
     @pyqtProperty(QObject, constant = True)
     def displayItem(self):

cura/MachineActionManager.py

@@ -1,12 +1,18 @@
 # Copyright (c) 2018 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
 
+from typing import TYPE_CHECKING, Optional, List, Set, Dict
+
 from PyQt5.QtCore import QObject
 
 from UM.FlameProfiler import pyqtSlot
 from UM.Logger import Logger
 from UM.PluginRegistry import PluginRegistry  # So MachineAction can be added as plugin type
-from UM.Settings.DefinitionContainer import DefinitionContainer
+
+if TYPE_CHECKING:
+    from cura.CuraApplication import CuraApplication
+    from cura.Settings.GlobalStack import GlobalStack
+    from .MachineAction import MachineAction
 
 
 ##  Raised when trying to add an unknown machine action as a required action
@@ -20,46 +26,54 @@ class NotUniqueMachineActionError(Exception):
 
 
 class MachineActionManager(QObject):
-    def __init__(self, application, parent = None):
-        super().__init__(parent)
+    def __init__(self, application: "CuraApplication", parent: Optional["QObject"] = None) -> None:
+        super().__init__(parent = parent)
         self._application = application
+        self._container_registry = self._application.getContainerRegistry()
 
-        self._machine_actions = {}  # Dict of all known machine actions
-        self._required_actions = {}  # Dict of all required actions by definition ID
-        self._supported_actions = {}  # Dict of all supported actions by definition ID
-        self._first_start_actions = {}  # Dict of all actions that need to be done when first added by definition ID
+        # Keeps track of which machines have already been processed so we don't do that again.
+        self._definition_ids_with_default_actions_added = set()  # type: Set[str]
+
+        # Dict of all known machine actions
+        self._machine_actions = {}  # type: Dict[str, MachineAction]
+        # Dict of all required actions by definition ID
+        self._required_actions = {}  # type: Dict[str, List[MachineAction]]
+        # Dict of all supported actions by definition ID
+        self._supported_actions = {}  # type: Dict[str, List[MachineAction]]
+        # Dict of all actions that need to be done when first added by definition ID
+        self._first_start_actions = {}  # type: Dict[str, List[MachineAction]]
 
     def initialize(self):
-        container_registry = self._application.getContainerRegistry()
-
         # Add machine_action as plugin type
         PluginRegistry.addType("machine_action", self.addMachineAction)
 
-        # Ensure that all containers that were registered before creation of this registry are also handled.
-        # This should not have any effect, but it makes it safer if we ever refactor the order of things.
-        for container in container_registry.findDefinitionContainers():
-            self._onContainerAdded(container)
+    # Adds all default machine actions that are defined in the machine definition for the given machine.
+    def addDefaultMachineActions(self, global_stack: "GlobalStack") -> None:
+        definition_id = global_stack.definition.getId()
 
-        container_registry.containerAdded.connect(self._onContainerAdded)
+        if definition_id in self._definition_ids_with_default_actions_added:
+            Logger.log("i", "Default machine actions have been added for machine definition [%s], do nothing.",
+                       definition_id)
+            return
 
-    def _onContainerAdded(self, container):
-        ## Ensure that the actions are added to this manager
-        if isinstance(container, DefinitionContainer):
-            supported_actions = container.getMetaDataEntry("supported_actions", [])
-            for action in supported_actions:
-                self.addSupportedAction(container.getId(), action)
+        supported_actions = global_stack.getMetaDataEntry("supported_actions", [])
+        for action_key in supported_actions:
+            self.addSupportedAction(definition_id, action_key)
 
-            required_actions = container.getMetaDataEntry("required_actions", [])
-            for action in required_actions:
-                self.addRequiredAction(container.getId(), action)
+        required_actions = global_stack.getMetaDataEntry("required_actions", [])
+        for action_key in required_actions:
+            self.addRequiredAction(definition_id, action_key)
 
-            first_start_actions = container.getMetaDataEntry("first_start_actions", [])
-            for action in first_start_actions:
-                self.addFirstStartAction(container.getId(), action)
+        first_start_actions = global_stack.getMetaDataEntry("first_start_actions", [])
+        for action_key in first_start_actions:
+            self.addFirstStartAction(definition_id, action_key)
+
+        self._definition_ids_with_default_actions_added.add(definition_id)
+        Logger.log("i", "Default machine actions added for machine definition [%s]", definition_id)
 
     ##  Add a required action to a machine
     #   Raises an exception when the action is not recognised.
-    def addRequiredAction(self, definition_id, action_key):
+    def addRequiredAction(self, definition_id: str, action_key: str) -> None:
         if action_key in self._machine_actions:
             if definition_id in self._required_actions:
                 if self._machine_actions[action_key] not in self._required_actions[definition_id]:
@@ -70,7 +84,7 @@ class MachineActionManager(QObject):
             raise UnknownMachineActionError("Action %s, which is required for %s is not known." % (action_key, definition_id))
 
     ##  Add a supported action to a machine.
-    def addSupportedAction(self, definition_id, action_key):
+    def addSupportedAction(self, definition_id: str, action_key: str) -> None:
         if action_key in self._machine_actions:
             if definition_id in self._supported_actions:
                 if self._machine_actions[action_key] not in self._supported_actions[definition_id]:
@@ -81,13 +95,10 @@ class MachineActionManager(QObject):
             Logger.log("w", "Unable to add %s to %s, as the action is not recognised", action_key, definition_id)
 
     ##  Add an action to the first start list of a machine.
-    def addFirstStartAction(self, definition_id, action_key, index = None):
+    def addFirstStartAction(self, definition_id: str, action_key: str) -> None:
         if action_key in self._machine_actions:
             if definition_id in self._first_start_actions:
-                if index is not None:
-                    self._first_start_actions[definition_id].insert(index, self._machine_actions[action_key])
-                else:
-                    self._first_start_actions[definition_id].append(self._machine_actions[action_key])
+                self._first_start_actions[definition_id].append(self._machine_actions[action_key])
             else:
                 self._first_start_actions[definition_id] = [self._machine_actions[action_key]]
         else:
@@ -95,7 +106,7 @@ class MachineActionManager(QObject):
 
     ##  Add a (unique) MachineAction
     #   if the Key of the action is not unique, an exception is raised.
-    def addMachineAction(self, action):
+    def addMachineAction(self, action: "MachineAction") -> None:
         if action.getKey() not in self._machine_actions:
             self._machine_actions[action.getKey()] = action
         else:
@@ -105,7 +116,7 @@ class MachineActionManager(QObject):
     #   \param definition_id The ID of the definition you want the supported actions of
     #   \returns set of supported actions.
     @pyqtSlot(str, result = "QVariantList")
-    def getSupportedActions(self, definition_id):
+    def getSupportedActions(self, definition_id: str) -> List["MachineAction"]:
         if definition_id in self._supported_actions:
             return list(self._supported_actions[definition_id])
         else:
@@ -114,11 +125,11 @@ class MachineActionManager(QObject):
     ##  Get all actions required by given machine
     #   \param definition_id The ID of the definition you want the required actions of
     #   \returns set of required actions.
-    def getRequiredActions(self, definition_id):
+    def getRequiredActions(self, definition_id: str) -> List["MachineAction"]:
         if definition_id in self._required_actions:
             return self._required_actions[definition_id]
         else:
-            return set()
+            return list()
 
     ##  Get all actions that need to be performed upon first start of a given machine.
     #   Note that contrary to required / supported actions a list is returned (as it could be required to run the same
@@ -126,7 +137,7 @@ class MachineActionManager(QObject):
     #   \param definition_id The ID of the definition that you want to get the "on added" actions for.
     #   \returns List of actions.
     @pyqtSlot(str, result="QVariantList")
-    def getFirstStartActions(self, definition_id):
+    def getFirstStartActions(self, definition_id: str) -> List["MachineAction"]:
         if definition_id in self._first_start_actions:
             return self._first_start_actions[definition_id]
         else:
@@ -134,7 +145,7 @@ class MachineActionManager(QObject):
 
     ##  Remove Machine action from manager
     #   \param action to remove
-    def removeMachineAction(self, action):
+    def removeMachineAction(self, action: "MachineAction") -> None:
         try:
             del self._machine_actions[action.getKey()]
         except KeyError:
@@ -143,7 +154,7 @@ class MachineActionManager(QObject):
     ##  Get MachineAction by key
     #   \param key String of key to select
     #   \return Machine action if found, None otherwise
-    def getMachineAction(self, key):
+    def getMachineAction(self, key: str) -> Optional["MachineAction"]:
         if key in self._machine_actions:
             return self._machine_actions[key]
         else:

cura/Machines/ContainerNode.py

@@ -9,9 +9,6 @@ from UM.ConfigurationErrorMessage import ConfigurationErrorMessage
 from UM.Logger import Logger
 from UM.Settings.InstanceContainer import InstanceContainer
 
-if TYPE_CHECKING:
-    from cura.Machines.QualityGroup import QualityGroup
-
 
 ##
 # A metadata / container combination. Use getContainer() to get the container corresponding to the metadata.
@@ -24,29 +21,34 @@ if TYPE_CHECKING:
 #     This is used in Variant, Material, and Quality Managers.
 #
 class ContainerNode:
-    __slots__ = ("metadata", "container", "children_map")
+    __slots__ = ("_metadata", "_container", "children_map")
 
     def __init__(self, metadata: Optional[Dict[str, Any]] = None) -> None:
-        self.metadata = metadata
-        self.container = None
-        self.children_map = OrderedDict() #type: OrderedDict[str, Union[QualityGroup, ContainerNode]]
+        self._metadata = metadata
+        self._container = None # type: Optional[InstanceContainer]
+        self.children_map = OrderedDict()  # type: ignore  # This is because it's children are supposed to override it.
 
     ##  Get an entry value from the metadata
     def getMetaDataEntry(self, entry: str, default: Any = None) -> Any:
-        if self.metadata is None:
+        if self._metadata is None:
             return default
-        return self.metadata.get(entry, default)
+        return self._metadata.get(entry, default)
+
+    def getMetadata(self) -> Dict[str, Any]:
+        if self._metadata is None:
+            return {}
+        return self._metadata
 
     def getChildNode(self, child_key: str) -> Optional["ContainerNode"]:
         return self.children_map.get(child_key)
 
     def getContainer(self) -> Optional["InstanceContainer"]:
-        if self.metadata is None:
+        if self._metadata is None:
             Logger.log("e", "Cannot get container for a ContainerNode without metadata.")
             return None
 
-        if self.container is None:
-            container_id = self.metadata["id"]
+        if self._container is None:
+            container_id = self._metadata["id"]
             from UM.Settings.ContainerRegistry import ContainerRegistry
             container_list = ContainerRegistry.getInstance().findInstanceContainers(id = container_id)
             if not container_list:
@@ -54,9 +56,9 @@ class ContainerNode:
                 error_message = ConfigurationErrorMessage.getInstance()
                 error_message.addFaultyContainers(container_id)
                 return None
-            self.container = container_list[0]
+            self._container = container_list[0]
 
-        return self.container
+        return self._container
 
     def __str__(self) -> str:
         return "%s[%s]" % (self.__class__.__name__, self.getMetaDataEntry("id"))

cura/Machines/MachineErrorChecker.py

@@ -50,7 +50,7 @@ class MachineErrorChecker(QObject):
         self._error_check_timer.setInterval(100)
         self._error_check_timer.setSingleShot(True)
 
-    def initialize(self):
+    def initialize(self) -> None:
         self._error_check_timer.timeout.connect(self._rescheduleCheck)
 
         # Reconnect all signals when the active machine gets changed.
@@ -62,23 +62,23 @@ class MachineErrorChecker(QObject):
 
         self._onMachineChanged()
 
-    def _onMachineChanged(self):
+    def _onMachineChanged(self) -> None:
         if self._global_stack:
-            self._global_stack.propertyChanged.disconnect(self.startErrorCheck)
+            self._global_stack.propertyChanged.disconnect(self.startErrorCheckPropertyChanged)
             self._global_stack.containersChanged.disconnect(self.startErrorCheck)
 
             for extruder in self._global_stack.extruders.values():
-                extruder.propertyChanged.disconnect(self.startErrorCheck)
+                extruder.propertyChanged.disconnect(self.startErrorCheckPropertyChanged)
                 extruder.containersChanged.disconnect(self.startErrorCheck)
 
         self._global_stack = self._machine_manager.activeMachine
 
         if self._global_stack:
-            self._global_stack.propertyChanged.connect(self.startErrorCheck)
+            self._global_stack.propertyChanged.connect(self.startErrorCheckPropertyChanged)
             self._global_stack.containersChanged.connect(self.startErrorCheck)
 
             for extruder in self._global_stack.extruders.values():
-                extruder.propertyChanged.connect(self.startErrorCheck)
+                extruder.propertyChanged.connect(self.startErrorCheckPropertyChanged)
                 extruder.containersChanged.connect(self.startErrorCheck)
 
     hasErrorUpdated = pyqtSignal()
@@ -93,8 +93,15 @@ class MachineErrorChecker(QObject):
     def needToWaitForResult(self) -> bool:
         return self._need_to_check or self._check_in_progress
 
+    #   Start the error check for property changed
+    #   this is seperate from the startErrorCheck because it ignores a number property types
+    def startErrorCheckPropertyChanged(self, key, property_name):
+        if property_name != "value":
+            return
+        self.startErrorCheck()
+
     # Starts the error check timer to schedule a new error check.
-    def startErrorCheck(self, *args):
+    def startErrorCheck(self, *args) -> None:
         if not self._check_in_progress:
             self._need_to_check = True
             self.needToWaitForResultChanged.emit()
@@ -103,7 +110,7 @@ class MachineErrorChecker(QObject):
     # This function is called by the timer to reschedule a new error check.
     # If there is no check in progress, it will start a new one. If there is any, it sets the "_need_to_check" flag
     # to notify the current check to stop and start a new one.
-    def _rescheduleCheck(self):
+    def _rescheduleCheck(self) -> None:
         if self._check_in_progress and not self._need_to_check:
             self._need_to_check = True
             self.needToWaitForResultChanged.emit()
@@ -128,7 +135,7 @@ class MachineErrorChecker(QObject):
         self._start_time = time.time()
         Logger.log("d", "New error check scheduled.")
 
-    def _checkStack(self):
+    def _checkStack(self) -> None:
         if self._need_to_check:
             Logger.log("d", "Need to check for errors again. Discard the current progress and reschedule a check.")
             self._check_in_progress = False
@@ -169,7 +176,7 @@ class MachineErrorChecker(QObject):
         # Schedule the check for the next key
         self._application.callLater(self._checkStack)
 
-    def _setResult(self, result: bool):
+    def _setResult(self, result: bool) -> None:
         if result != self._has_errors:
             self._has_errors = result
             self.hasErrorUpdated.emit()

cura/Machines/MaterialGroup.py

@@ -24,8 +24,8 @@ class MaterialGroup:
     def __init__(self, name: str, root_material_node: "MaterialNode") -> None:
         self.name = name
         self.is_read_only = False
-        self.root_material_node = root_material_node # type: MaterialNode
-        self.derived_material_node_list = [] # type: List[MaterialNode]
+        self.root_material_node = root_material_node  # type: MaterialNode
+        self.derived_material_node_list = []  # type: List[MaterialNode]
 
     def __str__(self) -> str:
         return "%s[%s]" % (self.__class__.__name__, self.name)

cura/Machines/MaterialManager.py

@@ -4,7 +4,7 @@
 from collections import defaultdict, OrderedDict
 import copy
 import uuid
-from typing import Dict, Optional, TYPE_CHECKING
+from typing import Dict, Optional, TYPE_CHECKING, Any, Set, List, cast, Tuple
 
 from PyQt5.Qt import QTimer, QObject, pyqtSignal, pyqtSlot
 
@@ -39,24 +39,34 @@ if TYPE_CHECKING:
 class MaterialManager(QObject):
 
     materialsUpdated = pyqtSignal()  # Emitted whenever the material lookup tables are updated.
+    favoritesUpdated = pyqtSignal()  # Emitted whenever the favorites are changed
 
     def __init__(self, container_registry, parent = None):
         super().__init__(parent)
         self._application = Application.getInstance()
         self._container_registry = container_registry  # type: ContainerRegistry
 
-        self._fallback_materials_map = dict()  # material_type -> generic material metadata
-        self._material_group_map = dict()  # root_material_id -> MaterialGroup
-        self._diameter_machine_nozzle_buildplate_material_map = dict()  # approximate diameter str -> dict(machine_definition_id -> MaterialNode)
+        # Material_type -> generic material metadata
+        self._fallback_materials_map = dict()  # type: Dict[str, Dict[str, Any]]
+
+        # Root_material_id -> MaterialGroup
+        self._material_group_map = dict()  # type: Dict[str, MaterialGroup]
+
+        # Approximate diameter str
+        self._diameter_machine_nozzle_buildplate_material_map = dict()  # type: Dict[str, Dict[str, MaterialNode]]
 
         # We're using these two maps to convert between the specific diameter material id and the generic material id
         # because the generic material ids are used in qualities and definitions, while the specific diameter material is meant
         # i.e. generic_pla -> generic_pla_175
-        self._material_diameter_map = defaultdict(dict)  # root_material_id -> approximate diameter str -> root_material_id for that diameter
-        self._diameter_material_map = dict()  # material id including diameter (generic_pla_175) -> material root id (generic_pla)
+        # root_material_id -> approximate diameter str -> root_material_id for that diameter
+        self._material_diameter_map = defaultdict(dict)  # type: Dict[str, Dict[str, str]]
+
+        # Material id including diameter (generic_pla_175) -> material root id (generic_pla)
+        self._diameter_material_map = dict()  # type: Dict[str, str]
 
         # This is used in Legacy UM3 send material function and the material management page.
-        self._guid_material_groups_map = defaultdict(list)  # GUID -> a list of material_groups
+        # GUID -> a list of material_groups
+        self._guid_material_groups_map = defaultdict(list)  # type: Dict[str, List[MaterialGroup]]
 
         # The machine definition ID for the non-machine-specific materials.
         # This is used as the last fallback option if the given machine-specific material(s) cannot be found.
@@ -75,13 +85,15 @@ class MaterialManager(QObject):
         self._container_registry.containerAdded.connect(self._onContainerMetadataChanged)
         self._container_registry.containerRemoved.connect(self._onContainerMetadataChanged)
 
-    def initialize(self):
+        self._favorites = set()  # type: Set[str]
+
+    def initialize(self) -> None:
         # Find all materials and put them in a matrix for quick search.
         material_metadatas = {metadata["id"]: metadata for metadata in
                               self._container_registry.findContainersMetadata(type = "material") if
-                              metadata.get("GUID")}
+                              metadata.get("GUID")} # type: Dict[str, Dict[str, Any]]
 
-        self._material_group_map = dict()
+        self._material_group_map = dict()  # type: Dict[str, MaterialGroup]
                 
         # Map #1
         #    root_material_id -> MaterialGroup
@@ -90,7 +102,7 @@ class MaterialManager(QObject):
             if material_id == "empty_material":
                 continue
 
-            root_material_id = material_metadata.get("base_file")
+            root_material_id = material_metadata.get("base_file", "")
             if root_material_id not in self._material_group_map:
                 self._material_group_map[root_material_id] = MaterialGroup(root_material_id, MaterialNode(material_metadatas[root_material_id]))
                 self._material_group_map[root_material_id].is_read_only = self._container_registry.isReadOnly(root_material_id)
@@ -106,26 +118,26 @@ class MaterialManager(QObject):
 
         # Map #1.5
         #    GUID -> material group list
-        self._guid_material_groups_map = defaultdict(list)
+        self._guid_material_groups_map = defaultdict(list)  # type: Dict[str, List[MaterialGroup]]
         for root_material_id, material_group in self._material_group_map.items():
-            guid = material_group.root_material_node.metadata["GUID"]
+            guid = material_group.root_material_node.getMetaDataEntry("GUID", "")
             self._guid_material_groups_map[guid].append(material_group)
 
         # Map #2
         # Lookup table for material type -> fallback material metadata, only for read-only materials
-        grouped_by_type_dict = dict()
+        grouped_by_type_dict = dict()  # type: Dict[str, Any]
         material_types_without_fallback = set()
         for root_material_id, material_node in self._material_group_map.items():
-            material_type = material_node.root_material_node.metadata["material"]
+            material_type = material_node.root_material_node.getMetaDataEntry("material", "")
             if material_type not in grouped_by_type_dict:
                 grouped_by_type_dict[material_type] = {"generic": None,
                                                        "others": []}
                 material_types_without_fallback.add(material_type)
-            brand = material_node.root_material_node.metadata["brand"]
+            brand = material_node.root_material_node.getMetaDataEntry("brand", "")
             if brand.lower() == "generic":
                 to_add = True
                 if material_type in grouped_by_type_dict:
-                    diameter = material_node.root_material_node.metadata.get("approximate_diameter")
+                    diameter = material_node.root_material_node.getMetaDataEntry("approximate_diameter", "")
                     if diameter != self._default_approximate_diameter_for_quality_search:
                         to_add = False  # don't add if it's not the default diameter
 
@@ -134,7 +146,7 @@ class MaterialManager(QObject):
                     #  - if it's in the list, it means that is a new material without fallback
                     #  - if it is not, then it is a custom material with a fallback material (parent)
                     if material_type in material_types_without_fallback:
-                        grouped_by_type_dict[material_type] = material_node.root_material_node.metadata
+                        grouped_by_type_dict[material_type] = material_node.root_material_node._metadata
                         material_types_without_fallback.remove(material_type)
 
         # Remove the materials that have no fallback materials
@@ -151,15 +163,15 @@ class MaterialManager(QObject):
         self._diameter_material_map = dict()
 
         # Group the material IDs by the same name, material, brand, and color but with different diameters.
-        material_group_dict = dict()
+        material_group_dict = dict()  # type: Dict[Tuple[Any], Dict[str, str]]
         keys_to_fetch = ("name", "material", "brand", "color")
         for root_material_id, machine_node in self._material_group_map.items():
-            root_material_metadata = machine_node.root_material_node.metadata
+            root_material_metadata = machine_node.root_material_node._metadata
 
-            key_data = []
+            key_data_list = []  # type: List[Any]
             for key in keys_to_fetch:
-                key_data.append(root_material_metadata.get(key))
-            key_data = tuple(key_data)
+                key_data_list.append(machine_node.root_material_node.getMetaDataEntry(key))
+            key_data = cast(Tuple[Any], tuple(key_data_list))  # type: Tuple[Any]
 
             # If the key_data doesn't exist, it doesn't matter if the material is read only...
             if key_data not in material_group_dict:
@@ -168,8 +180,8 @@ class MaterialManager(QObject):
                 # ...but if key_data exists, we just overwrite it if the material is read only, otherwise we skip it
                 if not machine_node.is_read_only:
                     continue
-            approximate_diameter = root_material_metadata.get("approximate_diameter")
-            material_group_dict[key_data][approximate_diameter] = root_material_metadata["id"]
+            approximate_diameter = machine_node.root_material_node.getMetaDataEntry("approximate_diameter", "")
+            material_group_dict[key_data][approximate_diameter] = machine_node.root_material_node.getMetaDataEntry("id", "")
 
         # Map [root_material_id][diameter] -> root_material_id for this diameter
         for data_dict in material_group_dict.values():
@@ -188,13 +200,17 @@ class MaterialManager(QObject):
 
         # Map #4
         # "machine" -> "nozzle name" -> "buildplate name" -> "root material ID" -> specific material InstanceContainer
-        self._diameter_machine_nozzle_buildplate_material_map = dict()
+        self._diameter_machine_nozzle_buildplate_material_map = dict()  # type: Dict[str, Dict[str, MaterialNode]]
         for material_metadata in material_metadatas.values():
             self.__addMaterialMetadataIntoLookupTree(material_metadata)
 
+        favorites = self._application.getPreferences().getValue("cura/favorite_materials")
+        for item in favorites.split(";"):
+            self._favorites.add(item)
+
         self.materialsUpdated.emit()
 
-    def __addMaterialMetadataIntoLookupTree(self, material_metadata: dict) -> None:
+    def __addMaterialMetadataIntoLookupTree(self, material_metadata: Dict[str, Any]) -> None:
         material_id = material_metadata["id"]
 
         # We don't store empty material in the lookup tables
@@ -281,11 +297,15 @@ class MaterialManager(QObject):
         return self._material_diameter_map.get(root_material_id, {}).get(approximate_diameter, root_material_id)
 
     def getRootMaterialIDWithoutDiameter(self, root_material_id: str) -> str:
-        return self._diameter_material_map.get(root_material_id)
+        return self._diameter_material_map.get(root_material_id, "")
 
-    def getMaterialGroupListByGUID(self, guid: str) -> Optional[list]:
+    def getMaterialGroupListByGUID(self, guid: str) -> Optional[List[MaterialGroup]]:
         return self._guid_material_groups_map.get(guid)
 
+    # Returns a dict of all material groups organized by root_material_id.
+    def getAllMaterialGroups(self) -> Dict[str, "MaterialGroup"]:
+        return self._material_group_map
+
     #
     # Return a dict with all root material IDs (k) and ContainerNodes (v) that's suitable for the given setup.
     #
@@ -321,6 +341,7 @@ class MaterialManager(QObject):
         machine_exclude_materials = machine_definition.getMetaDataEntry("exclude_materials", [])
 
         material_id_metadata_dict = dict()  # type: Dict[str, MaterialNode]
+        excluded_materials = set()
         for current_node in nodes_to_check:
             if current_node is None:
                 continue
@@ -329,25 +350,27 @@ class MaterialManager(QObject):
             # Do not exclude other materials that are of the same type.
             for material_id, node in current_node.material_map.items():
                 if material_id in machine_exclude_materials:
-                    Logger.log("d", "Exclude material [%s] for machine [%s]",
-                               material_id, machine_definition.getId())
+                    excluded_materials.add(material_id)
                     continue
 
                 if material_id not in material_id_metadata_dict:
                     material_id_metadata_dict[material_id] = node
 
+        if excluded_materials:
+            Logger.log("d", "Exclude materials {excluded_materials} for machine {machine_definition_id}".format(excluded_materials = ", ".join(excluded_materials), machine_definition_id = machine_definition_id))
+
         return material_id_metadata_dict
 
     #
     # A convenience function to get available materials for the given machine with the extruder position.
     #
     def getAvailableMaterialsForMachineExtruder(self, machine: "GlobalStack",
-                                                extruder_stack: "ExtruderStack") -> Optional[dict]:
+                                                extruder_stack: "ExtruderStack") -> Optional[Dict[str, MaterialNode]]:
         buildplate_name = machine.getBuildplateName()
         nozzle_name = None
         if extruder_stack.variant.getId() != "empty_variant":
             nozzle_name = extruder_stack.variant.getName()
-        diameter = extruder_stack.approximateMaterialDiameter
+        diameter = extruder_stack.getApproximateMaterialDiameter()
 
         # Fetch the available materials (ContainerNode) for the current active machine and extruder setup.
         return self.getAvailableMaterials(machine.definition, nozzle_name, buildplate_name, diameter)
@@ -359,7 +382,7 @@ class MaterialManager(QObject):
     #  2. cannot find any material InstanceContainers with the given settings.
     #
     def getMaterialNode(self, machine_definition_id: str, nozzle_name: Optional[str],
-                        buildplate_name: Optional[str], diameter: float, root_material_id: str) -> Optional["InstanceContainer"]:
+                        buildplate_name: Optional[str], diameter: float, root_material_id: str) -> Optional["MaterialNode"]:
         # round the diameter to get the approximate diameter
         rounded_diameter = str(round(diameter))
         if rounded_diameter not in self._diameter_machine_nozzle_buildplate_material_map:
@@ -368,7 +391,7 @@ class MaterialManager(QObject):
             return None
 
         # If there are nozzle materials, get the nozzle-specific material
-        machine_nozzle_buildplate_material_map = self._diameter_machine_nozzle_buildplate_material_map[rounded_diameter]
+        machine_nozzle_buildplate_material_map = self._diameter_machine_nozzle_buildplate_material_map[rounded_diameter]  # type: Dict[str, MaterialNode]
         machine_node = machine_nozzle_buildplate_material_map.get(machine_definition_id)
         nozzle_node = None
         buildplate_node = None
@@ -417,7 +440,7 @@ class MaterialManager(QObject):
             # Look at the guid to material dictionary
             root_material_id = None
             for material_group in self._guid_material_groups_map[material_guid]:
-                root_material_id = material_group.root_material_node.metadata["id"]
+                root_material_id = cast(str, material_group.root_material_node.getMetaDataEntry("id", ""))
                 break
 
             if not root_material_id:
@@ -428,6 +451,28 @@ class MaterialManager(QObject):
                                         material_diameter, root_material_id)
         return node
 
+    #   There are 2 ways to get fallback materials;
+    #   - A fallback by type (@sa getFallbackMaterialIdByMaterialType), which adds the generic version of this material
+    #   - A fallback by GUID; If a material has been duplicated, it should also check if the original materials do have
+    #       a GUID. This should only be done if the material itself does not have a quality just yet.
+    def getFallBackMaterialIdsByMaterial(self, material: "InstanceContainer") -> List[str]:
+        results = []  # type: List[str]
+
+        material_groups = self.getMaterialGroupListByGUID(material.getMetaDataEntry("GUID"))
+        for material_group in material_groups:  # type: ignore
+            if material_group.name != material.getId():
+                # If the material in the group is read only, put it at the front of the list (since that is the most
+                # likely one to get a result)
+                if material_group.is_read_only:
+                    results.insert(0, material_group.name)
+                else:
+                    results.append(material_group.name)
+
+        fallback = self.getFallbackMaterialIdByMaterialType(material.getMetaDataEntry("material"))
+        if fallback is not None:
+            results.append(fallback)
+        return results
+
     #
     # Used by QualityManager. Built-in quality profiles may be based on generic material IDs such as "generic_pla".
     # For materials such as ultimaker_pla_orange, no quality profiles may be found, so we should fall back to use
@@ -460,12 +505,22 @@ class MaterialManager(QObject):
 
         buildplate_name = global_stack.getBuildplateName()
         machine_definition = global_stack.definition
-        if extruder_definition is None:
-            extruder_definition = global_stack.extruders[position].definition
 
-        if extruder_definition and parseBool(global_stack.getMetaDataEntry("has_materials", False)):
-            # At this point the extruder_definition is not None
-            material_diameter = extruder_definition.getProperty("material_diameter", "value")
+        # The extruder-compatible material diameter in the extruder definition may not be the correct value because
+        # the user can change it in the definition_changes container.
+        if extruder_definition is None:
+            extruder_stack_or_definition = global_stack.extruders[position]
+            is_extruder_stack = True
+        else:
+            extruder_stack_or_definition = extruder_definition
+            is_extruder_stack = False
+
+        if extruder_stack_or_definition and parseBool(global_stack.getMetaDataEntry("has_materials", False)):
+            if is_extruder_stack:
+                material_diameter = extruder_stack_or_definition.getCompatibleMaterialDiameter()
+            else:
+                material_diameter = extruder_stack_or_definition.getProperty("material_diameter", "value")
+
             if isinstance(material_diameter, SettingFunction):
                 material_diameter = material_diameter(global_stack)
             approximate_material_diameter = str(round(material_diameter))
@@ -493,7 +548,7 @@ class MaterialManager(QObject):
     # Sets the new name for the given material.
     #
     @pyqtSlot("QVariant", str)
-    def setMaterialName(self, material_node: "MaterialNode", name: str):
+    def setMaterialName(self, material_node: "MaterialNode", name: str) -> None:
         root_material_id = material_node.getMetaDataEntry("base_file")
         if root_material_id is None:
             return
@@ -511,7 +566,7 @@ class MaterialManager(QObject):
     # Removes the given material.
     #
     @pyqtSlot("QVariant")
-    def removeMaterial(self, material_node: "MaterialNode"):
+    def removeMaterial(self, material_node: "MaterialNode") -> None:
         root_material_id = material_node.getMetaDataEntry("base_file")
         if root_material_id is not None:
             self.removeMaterialByRootId(root_material_id)
@@ -521,8 +576,8 @@ class MaterialManager(QObject):
     # Returns the root material ID of the duplicated material if successful.
     #
     @pyqtSlot("QVariant", result = str)
-    def duplicateMaterial(self, material_node, new_base_id = None, new_metadata = None) -> Optional[str]:
-        root_material_id = material_node.metadata["base_file"]
+    def duplicateMaterial(self, material_node: MaterialNode, new_base_id: Optional[str] = None, new_metadata: Dict[str, Any] = None) -> Optional[str]:
+        root_material_id = cast(str, material_node.getMetaDataEntry("base_file", ""))
 
         material_group = self.getMaterialGroup(root_material_id)
         if not material_group:
@@ -573,11 +628,16 @@ class MaterialManager(QObject):
         for container_to_add in new_containers:
             container_to_add.setDirty(True)
             self._container_registry.addContainer(container_to_add)
+
+        # if the duplicated material was favorite then the new material should also be added to favorite.
+        if root_material_id in self.getFavorites():
+            self.addFavorite(new_base_id)
+
         return new_base_id
 
     #
     # Create a new material by cloning Generic PLA for the current material diameter and generate a new GUID.
-    #
+    # Returns the ID of the newly created material.
     @pyqtSlot(result = str)
     def createMaterial(self) -> str:
         from UM.i18n import i18nCatalog
@@ -588,8 +648,10 @@ class MaterialManager(QObject):
         machine_manager = self._application.getMachineManager()
         extruder_stack = machine_manager.activeStack
 
+        machine_definition = self._application.getGlobalContainerStack().definition
+        root_material_id = machine_definition.getMetaDataEntry("preferred_material", default = "generic_pla")
+
         approximate_diameter = str(extruder_stack.approximateMaterialDiameter)
-        root_material_id = "generic_pla"
         root_material_id = self.getRootMaterialIDForDiameter(root_material_id, approximate_diameter)
         material_group = self.getMaterialGroup(root_material_id)
 
@@ -608,3 +670,29 @@ class MaterialManager(QObject):
                                new_base_id = new_id,
                                new_metadata = new_metadata)
         return new_id
+
+    @pyqtSlot(str)
+    def addFavorite(self, root_material_id: str) -> None:
+        self._favorites.add(root_material_id)
+        self.materialsUpdated.emit()
+
+        # Ensure all settings are saved.
+        self._application.getPreferences().setValue("cura/favorite_materials", ";".join(list(self._favorites)))
+        self._application.saveSettings()
+
+    @pyqtSlot(str)
+    def removeFavorite(self, root_material_id: str) -> None:
+        try:
+            self._favorites.remove(root_material_id)
+        except KeyError:
+            Logger.log("w", "Could not delete material %s from favorites as it was already deleted", root_material_id)
+            return
+        self.materialsUpdated.emit()
+
+        # Ensure all settings are saved.
+        self._application.getPreferences().setValue("cura/favorite_materials", ";".join(list(self._favorites)))
+        self._application.saveSettings()
+
+    @pyqtSlot()
+    def getFavorites(self):
+        return self._favorites

cura/Machines/MaterialNode.py

@@ -1,7 +1,7 @@
 # Copyright (c) 2018 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
-from typing import Optional, Dict
-
+from typing import Optional, Dict, Any
+from collections import OrderedDict
 from .ContainerNode import ContainerNode
 
 
@@ -14,6 +14,12 @@ from .ContainerNode import ContainerNode
 class MaterialNode(ContainerNode):
     __slots__ = ("material_map", "children_map")
 
-    def __init__(self, metadata: Optional[dict] = None) -> None:
+    def __init__(self, metadata: Optional[Dict[str, Any]] = None) -> None:
         super().__init__(metadata = metadata)
         self.material_map = {}  # type: Dict[str, MaterialNode] # material_root_id -> material_node
+
+        # We overide this as we want to indicate that MaterialNodes can only contain other material nodes.
+        self.children_map = OrderedDict()  # type: OrderedDict[str, "MaterialNode"]
+
+    def getChildNode(self, child_key: str) -> Optional["MaterialNode"]:
+        return self.children_map.get(child_key)

cura/Machines/Models/BaseMaterialsModel.py

@@ -1,46 +1,66 @@
 # Copyright (c) 2018 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
+from typing import Optional, Dict, Set
 
 from PyQt5.QtCore import Qt, pyqtSignal, pyqtProperty
-
-from UM.Application import Application
 from UM.Qt.ListModel import ListModel
 
 
-#
-# This is the base model class for GenericMaterialsModel and BrandMaterialsModel
-# Those 2 models are used by the material drop down menu to show generic materials and branded materials separately.
-# The extruder position defined here is being used to bound a menu to the correct extruder. This is used in the top
-# bar menu "Settings" -> "Extruder nr" -> "Material" -> this menu
-#
+## This is the base model class for GenericMaterialsModel and MaterialBrandsModel.
+#  Those 2 models are used by the material drop down menu to show generic materials and branded materials separately.
+#  The extruder position defined here is being used to bound a menu to the correct extruder. This is used in the top
+#  bar menu "Settings" -> "Extruder nr" -> "Material" -> this menu
+from cura.Machines.MaterialNode import MaterialNode
+
+
 class BaseMaterialsModel(ListModel):
-    RootMaterialIdRole = Qt.UserRole + 1
-    IdRole = Qt.UserRole + 2
-    NameRole = Qt.UserRole + 3
-    BrandRole = Qt.UserRole + 4
-    MaterialRole = Qt.UserRole + 5
-    ColorRole = Qt.UserRole + 6
-    ContainerNodeRole = Qt.UserRole + 7
 
     extruderPositionChanged = pyqtSignal()
+    enabledChanged = pyqtSignal()
 
     def __init__(self, parent = None):
         super().__init__(parent)
-        self._application = Application.getInstance()
-        self._machine_manager = self._application.getMachineManager()
+        from cura.CuraApplication import CuraApplication
 
-        self.addRoleName(self.RootMaterialIdRole, "root_material_id")
-        self.addRoleName(self.IdRole, "id")
-        self.addRoleName(self.NameRole, "name")
-        self.addRoleName(self.BrandRole, "brand")
-        self.addRoleName(self.MaterialRole, "material")
-        self.addRoleName(self.ColorRole, "color_name")
-        self.addRoleName(self.ContainerNodeRole, "container_node")
+        self._application = CuraApplication.getInstance()
+
+        # Make these managers available to all material models
+        self._container_registry = self._application.getInstance().getContainerRegistry()
+        self._machine_manager = self._application.getMachineManager()
+        self._material_manager = self._application.getMaterialManager()
+
+        # Update the stack and the model data when the machine changes
+        self._machine_manager.globalContainerChanged.connect(self._updateExtruderStack)
+
+        # Update this model when switching machines
+        self._machine_manager.activeStackChanged.connect(self._update)
+        
+        # Update this model when list of materials changes
+        self._material_manager.materialsUpdated.connect(self._update)
+
+        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._extruder_position = 0
         self._extruder_stack = None
-        # Update the stack and the model data when the machine changes
-        self._machine_manager.globalContainerChanged.connect(self._updateExtruderStack)
+
+        self._available_materials = None  # type: Optional[Dict[str, MaterialNode]]
+        self._favorite_ids = set()  # type: Set[str]
+        self._enabled = True
 
     def _updateExtruderStack(self):
         global_stack = self._machine_manager.activeMachine
@@ -49,9 +69,11 @@ class BaseMaterialsModel(ListModel):
 
         if self._extruder_stack is not None:
             self._extruder_stack.pyqtContainersChanged.disconnect(self._update)
+            self._extruder_stack.approximateMaterialDiameterChanged.disconnect(self._update)
         self._extruder_stack = global_stack.extruders.get(str(self._extruder_position))
         if self._extruder_stack is not None:
             self._extruder_stack.pyqtContainersChanged.connect(self._update)
+            self._extruder_stack.approximateMaterialDiameterChanged.connect(self._update)
         # Force update the model when the extruder stack changes
         self._update()
 
@@ -65,8 +87,66 @@ class BaseMaterialsModel(ListModel):
     def extruderPosition(self) -> int:
         return self._extruder_position
 
-    #
-    # This is an abstract method that needs to be implemented by
-    #
+    def setEnabled(self, enabled):
+        if self._enabled != enabled:
+            self._enabled = enabled
+            if self._enabled:
+                # ensure the data is there again.
+                self._update()
+            self.enabledChanged.emit()
+
+    @pyqtProperty(bool, fset=setEnabled, notify=enabledChanged)
+    def enabled(self):
+        return self._enabled
+
+    ## This is an abstract method that needs to be implemented by the specific
+    #  models themselves.
     def _update(self):
         pass
+
+    ## This method is used by all material models in the beginning of the
+    #  _update() method in order to prevent errors. It's the same in all models
+    #  so it's placed here for easy access.
+    def _canUpdate(self):
+        global_stack = self._machine_manager.activeMachine
+
+        if global_stack is None or not self._enabled:
+            return False
+
+        extruder_position = str(self._extruder_position)
+
+        if extruder_position not in global_stack.extruders:
+            return False
+        
+        extruder_stack = global_stack.extruders[extruder_position]
+        self._available_materials = self._material_manager.getAvailableMaterialsForMachineExtruder(global_stack, extruder_stack)
+        if self._available_materials is None:
+            return False
+
+        return True
+
+    ## This is another convenience function which is shared by all material
+    #  models so it's put here to avoid having so much duplicated code.
+    def _createMaterialItem(self, root_material_id, container_node):
+        metadata = container_node.getMetadata()
+        item = {
+            "root_material_id":     root_material_id,
+            "id":                   metadata["id"],
+            "container_id":         metadata["id"], # TODO: Remove duplicate in material manager qml
+            "GUID":                 metadata["GUID"],
+            "name":                 metadata["name"],
+            "brand":                metadata["brand"],
+            "description":          metadata["description"],
+            "material":             metadata["material"],
+            "color_name":           metadata["color_name"],
+            "color_code":           metadata.get("color_code", ""),
+            "density":              metadata.get("properties", {}).get("density", ""),
+            "diameter":             metadata.get("properties", {}).get("diameter", ""),
+            "approximate_diameter": metadata["approximate_diameter"],
+            "adhesion_info":        metadata["adhesion_info"],
+            "is_read_only":         self._container_registry.isReadOnly(metadata["id"]),
+            "container_node":       container_node,
+            "is_favorite":          root_material_id in self._favorite_ids
+        }
+        return item
+

cura/Machines/Models/BrandMaterialsModel.py

@@ -1,157 +0,0 @@
-# Copyright (c) 2018 Ultimaker B.V.
-# Cura is released under the terms of the LGPLv3 or higher.
-
-from PyQt5.QtCore import Qt, pyqtSignal, pyqtProperty
-
-from UM.Qt.ListModel import ListModel
-from UM.Logger import Logger
-from cura.Machines.Models.BaseMaterialsModel import BaseMaterialsModel
-
-
-#
-# This is an intermediate model to group materials with different colours for a same brand and type.
-#
-class MaterialsModelGroupedByType(ListModel):
-    NameRole = Qt.UserRole + 1
-    ColorsRole = Qt.UserRole + 2
-
-    def __init__(self, parent = None):
-        super().__init__(parent)
-
-        self.addRoleName(self.NameRole, "name")
-        self.addRoleName(self.ColorsRole, "colors")
-
-
-#
-# This model is used to show branded materials in the material drop down menu.
-# The structure of the menu looks like this:
-#       Brand -> Material Type -> list of materials
-#
-# To illustrate, a branded material menu may look like this:
-#      Ultimaker -> PLA -> Yellow PLA
-#                       -> Black PLA
-#                       -> ...
-#                -> ABS -> White ABS
-#                          ...
-#
-class BrandMaterialsModel(ListModel):
-    NameRole = Qt.UserRole + 1
-    MaterialsRole = Qt.UserRole + 2
-
-    extruderPositionChanged = pyqtSignal()
-
-    def __init__(self, parent = None):
-        super().__init__(parent)
-
-        self.addRoleName(self.NameRole, "name")
-        self.addRoleName(self.MaterialsRole, "materials")
-
-        self._extruder_position = 0
-        self._extruder_stack = None
-
-        from cura.CuraApplication import CuraApplication
-        self._machine_manager = CuraApplication.getInstance().getMachineManager()
-        self._extruder_manager = CuraApplication.getInstance().getExtruderManager()
-        self._material_manager = CuraApplication.getInstance().getMaterialManager()
-
-        self._machine_manager.globalContainerChanged.connect(self._updateExtruderStack)
-        self._machine_manager.activeStackChanged.connect(self._update) #Update when switching machines.
-        self._material_manager.materialsUpdated.connect(self._update) #Update when the list of materials changes.
-        self._update()
-
-    def _updateExtruderStack(self):
-        global_stack = self._machine_manager.activeMachine
-        if global_stack is None:
-            return
-
-        if self._extruder_stack is not None:
-            self._extruder_stack.pyqtContainersChanged.disconnect(self._update)
-        self._extruder_stack = global_stack.extruders.get(str(self._extruder_position))
-        if self._extruder_stack is not None:
-            self._extruder_stack.pyqtContainersChanged.connect(self._update)
-        # Force update the model when the extruder stack changes
-        self._update()
-
-    def setExtruderPosition(self, position: int):
-        if self._extruder_stack is None or self._extruder_position != position:
-            self._extruder_position = position
-            self._updateExtruderStack()
-            self.extruderPositionChanged.emit()
-
-    @pyqtProperty(int, fset=setExtruderPosition, notify=extruderPositionChanged)
-    def extruderPosition(self) -> int:
-        return self._extruder_position
-
-    def _update(self):
-        Logger.log("d", "Updating {model_class_name}.".format(model_class_name = self.__class__.__name__))
-        global_stack = self._machine_manager.activeMachine
-        if global_stack is None:
-            self.setItems([])
-            return
-        extruder_position = str(self._extruder_position)
-        if extruder_position not in global_stack.extruders:
-            self.setItems([])
-            return
-        extruder_stack = global_stack.extruders[str(self._extruder_position)]
-
-        available_material_dict = self._material_manager.getAvailableMaterialsForMachineExtruder(global_stack,
-                                                                                                 extruder_stack)
-        if available_material_dict is None:
-            self.setItems([])
-            return
-
-        brand_item_list = []
-        brand_group_dict = {}
-        for root_material_id, container_node in available_material_dict.items():
-            metadata = container_node.metadata
-            brand = metadata["brand"]
-            # Only add results for generic materials
-            if brand.lower() == "generic":
-                continue
-
-            # Do not include the materials from a to-be-removed package
-            if bool(metadata.get("removed", False)):
-                continue
-
-            if brand not in brand_group_dict:
-                brand_group_dict[brand] = {}
-
-            material_type = metadata["material"]
-            if material_type not in brand_group_dict[brand]:
-                brand_group_dict[brand][material_type] = []
-
-            item = {"root_material_id": root_material_id,
-                    "id": metadata["id"],
-                    "name": metadata["name"],
-                    "brand": metadata["brand"],
-                    "material": metadata["material"],
-                    "color_name": metadata["color_name"],
-                    "container_node": container_node
-                    }
-            brand_group_dict[brand][material_type].append(item)
-
-        for brand, material_dict in brand_group_dict.items():
-            brand_item = {"name": brand,
-                          "materials": MaterialsModelGroupedByType(self)}
-
-            material_type_item_list = []
-            for material_type, material_list in material_dict.items():
-                material_type_item = {"name": material_type,
-                                      "colors": BaseMaterialsModel(self)}
-                material_type_item["colors"].clear()
-
-                # Sort materials by name
-                material_list = sorted(material_list, key = lambda x: x["name"].upper())
-                material_type_item["colors"].setItems(material_list)
-
-                material_type_item_list.append(material_type_item)
-
-            # Sort material type by name
-            material_type_item_list = sorted(material_type_item_list, key = lambda x: x["name"].upper())
-            brand_item["materials"].setItems(material_type_item_list)
-
-            brand_item_list.append(brand_item)
-
-        # Sort brand by name
-        brand_item_list = sorted(brand_item_list, key = lambda x: x["name"].upper())
-        self.setItems(brand_item_list)

cura/Machines/Models/FavoriteMaterialsModel.py

@@ -0,0 +1,38 @@
+# Copyright (c) 2018 Ultimaker B.V.
+# Cura is released under the terms of the LGPLv3 or higher.
+
+from cura.Machines.Models.BaseMaterialsModel import BaseMaterialsModel
+
+##  Model that shows the list of favorite materials.
+class FavoriteMaterialsModel(BaseMaterialsModel):
+    def __init__(self, parent = None):
+        super().__init__(parent)
+        self._update()
+
+    def _update(self):
+        if not self._canUpdate():
+            return
+
+        # Get updated list of favorites
+        self._favorite_ids = self._material_manager.getFavorites()
+
+        item_list = []
+
+        for root_material_id, container_node in self._available_materials.items():
+            metadata = container_node.getMetadata()
+
+            # Do not include the materials from a to-be-removed package
+            if bool(metadata.get("removed", False)):
+                continue
+
+            # Only add results for favorite materials
+            if root_material_id not in self._favorite_ids:
+                continue
+
+            item = self._createMaterialItem(root_material_id, container_node)
+            item_list.append(item)
+
+        # Sort the item list alphabetically by name
+        item_list = sorted(item_list, key = lambda d: d["brand"].upper())
+
+        self.setItems(item_list)

cura/Machines/Models/GenericMaterialsModel.py

@@ -4,63 +4,36 @@
 from UM.Logger import Logger
 from cura.Machines.Models.BaseMaterialsModel import BaseMaterialsModel
 
-
 class GenericMaterialsModel(BaseMaterialsModel):
 
     def __init__(self, parent = None):
         super().__init__(parent)
-
-        from cura.CuraApplication import CuraApplication
-        self._machine_manager = CuraApplication.getInstance().getMachineManager()
-        self._extruder_manager = CuraApplication.getInstance().getExtruderManager()
-        self._material_manager = CuraApplication.getInstance().getMaterialManager()
-
-        self._machine_manager.activeStackChanged.connect(self._update) #Update when switching machines.
-        self._material_manager.materialsUpdated.connect(self._update) #Update when the list of materials changes.
         self._update()
 
     def _update(self):
-        Logger.log("d", "Updating {model_class_name}.".format(model_class_name = self.__class__.__name__))
+        if not self._canUpdate():
+            return
 
-        global_stack = self._machine_manager.activeMachine
-        if global_stack is None:
-            self.setItems([])
-            return
-        extruder_position = str(self._extruder_position)
-        if extruder_position not in global_stack.extruders:
-            self.setItems([])
-            return
-        extruder_stack = global_stack.extruders[extruder_position]
-
-        available_material_dict = self._material_manager.getAvailableMaterialsForMachineExtruder(global_stack,
-                                                                                                 extruder_stack)
-        if available_material_dict is None:
-            self.setItems([])
-            return
+        # Get updated list of favorites
+        self._favorite_ids = self._material_manager.getFavorites()
 
         item_list = []
-        for root_material_id, container_node in available_material_dict.items():
-            metadata = container_node.metadata
 
-            # Only add results for generic materials
-            if metadata["brand"].lower() != "generic":
-                continue
+        for root_material_id, container_node in self._available_materials.items():
+            metadata = container_node.getMetadata()
 
             # Do not include the materials from a to-be-removed package
             if bool(metadata.get("removed", False)):
                 continue
 
-            item = {"root_material_id": root_material_id,
-                    "id": metadata["id"],
-                    "name": metadata["name"],
-                    "brand": metadata["brand"],
-                    "material": metadata["material"],
-                    "color_name": metadata["color_name"],
-                    "container_node": container_node
-                    }
+            # Only add results for generic materials
+            if metadata["brand"].lower() != "generic":
+                continue
+
+            item = self._createMaterialItem(root_material_id, container_node)
             item_list.append(item)
 
-        # Sort the item list by material name alphabetically
+        # Sort the item list alphabetically by name
         item_list = sorted(item_list, key = lambda d: d["name"].upper())
 
         self.setItems(item_list)

cura/Machines/Models/MachineManagementModel.py

@@ -52,14 +52,14 @@ class MachineManagementModel(ListModel):
                                    "um_network_key": "*",
                                    "hidden": "False"}
         self._network_container_stacks = ContainerRegistry.getInstance().findContainerStacks(**network_filter_printers)
-        self._network_container_stacks.sort(key = lambda i: i.getMetaDataEntry("connect_group_name"))
+        self._network_container_stacks.sort(key = lambda i: i.getMetaDataEntry("group_name", ""))
 
         for container in self._network_container_stacks:
             metadata = container.getMetaData().copy()
             if container.getBottom():
                 metadata["definition_name"] = container.getBottom().getName()
 
-            items.append({"name": metadata["connect_group_name"],
+            items.append({"name": metadata.get("group_name", ""),
                           "id": container.getId(),
                           "metadata": metadata,
                           "group": catalog.i18nc("@info:title", "Network enabled printers")})

cura/Machines/Models/MaterialBrandsModel.py

@@ -0,0 +1,103 @@
+# Copyright (c) 2018 Ultimaker B.V.
+# Cura is released under the terms of the LGPLv3 or higher.
+
+from PyQt5.QtCore import Qt, pyqtSignal, pyqtProperty
+from UM.Qt.ListModel import ListModel
+from UM.Logger import Logger
+from cura.Machines.Models.BaseMaterialsModel import BaseMaterialsModel
+
+class MaterialTypesModel(ListModel):
+
+    def __init__(self, parent = None):
+        super().__init__(parent)
+
+        self.addRoleName(Qt.UserRole + 1, "name")
+        self.addRoleName(Qt.UserRole + 2, "brand")
+        self.addRoleName(Qt.UserRole + 3, "colors")
+
+class MaterialBrandsModel(BaseMaterialsModel):
+
+    extruderPositionChanged = pyqtSignal()
+
+    def __init__(self, parent = None):
+        super().__init__(parent)
+
+        self.addRoleName(Qt.UserRole + 1, "name")
+        self.addRoleName(Qt.UserRole + 2, "material_types")
+
+        self._update()
+
+    def _update(self):
+        if not self._canUpdate():
+            return
+        # Get updated list of favorites
+        self._favorite_ids = self._material_manager.getFavorites()
+
+        brand_item_list = []
+        brand_group_dict = {}
+
+        # Part 1: Generate the entire tree of brands -> material types -> spcific materials
+        for root_material_id, container_node in self._available_materials.items():
+            # Do not include the materials from a to-be-removed package
+            if bool(container_node.getMetaDataEntry("removed", False)):
+                continue
+
+            # Add brands we haven't seen yet to the dict, skipping generics
+            brand = container_node.getMetaDataEntry("brand", "")
+            if brand.lower() == "generic":
+                continue
+            if brand not in brand_group_dict:
+                brand_group_dict[brand] = {}
+
+            # Add material types we haven't seen yet to the dict
+            material_type = container_node.getMetaDataEntry("material", "")
+            if material_type not in brand_group_dict[brand]:
+                brand_group_dict[brand][material_type] = []
+
+            # Now handle the individual materials
+            item = self._createMaterialItem(root_material_id, container_node)
+            brand_group_dict[brand][material_type].append(item)
+
+        # Part 2: Organize the tree into models
+        #
+        # Normally, the structure of the menu looks like this:
+        #     Brand -> Material Type -> Specific Material
+        #
+        # To illustrate, a branded material menu may look like this:
+        #     Ultimaker ┳ PLA ┳ Yellow PLA
+        #               ┃     ┣ Black PLA
+        #               ┃     ┗ ...
+        #               ┃
+        #               ┗ ABS ┳ White ABS
+        #                     ┗ ...
+        for brand, material_dict in brand_group_dict.items():
+
+            material_type_item_list = []
+            brand_item = {
+                "name": brand,
+                "material_types": MaterialTypesModel(self)
+            }
+
+            for material_type, material_list in material_dict.items():
+                material_type_item = {
+                    "name": material_type,
+                    "brand": brand,
+                    "colors": BaseMaterialsModel(self)
+                }
+                material_type_item["colors"].clear()
+
+                # Sort materials by name
+                material_list = sorted(material_list, key = lambda x: x["name"].upper())
+                material_type_item["colors"].setItems(material_list)
+
+                material_type_item_list.append(material_type_item)
+
+            # Sort material type by name
+            material_type_item_list = sorted(material_type_item_list, key = lambda x: x["name"].upper())
+            brand_item["material_types"].setItems(material_type_item_list)
+
+            brand_item_list.append(brand_item)
+
+        # Sort brand by name
+        brand_item_list = sorted(brand_item_list, key = lambda x: x["name"].upper())
+        self.setItems(brand_item_list)

cura/Machines/Models/MaterialManagementModel.py

@@ -1,104 +0,0 @@
-# Copyright (c) 2018 Ultimaker B.V.
-# Cura is released under the terms of the LGPLv3 or higher.
-
-from PyQt5.QtCore import Qt
-
-from UM.Logger import Logger
-from UM.Qt.ListModel import ListModel
-
-
-#
-# This model is for the Material management page.
-#
-class MaterialManagementModel(ListModel):
-    RootMaterialIdRole = Qt.UserRole + 1
-    DisplayNameRole = Qt.UserRole + 2
-    BrandRole = Qt.UserRole + 3
-    MaterialTypeRole = Qt.UserRole + 4
-    ColorNameRole = Qt.UserRole + 5
-    ColorCodeRole = Qt.UserRole + 6
-    ContainerNodeRole = Qt.UserRole + 7
-    ContainerIdRole = Qt.UserRole + 8
-
-    DescriptionRole = Qt.UserRole + 9
-    AdhesionInfoRole = Qt.UserRole + 10
-    ApproximateDiameterRole = Qt.UserRole + 11
-    GuidRole = Qt.UserRole + 12
-    DensityRole = Qt.UserRole + 13
-    DiameterRole = Qt.UserRole + 14
-    IsReadOnlyRole = Qt.UserRole + 15
-
-    def __init__(self, parent = None):
-        super().__init__(parent)
-
-        self.addRoleName(self.RootMaterialIdRole, "root_material_id")
-        self.addRoleName(self.DisplayNameRole, "name")
-        self.addRoleName(self.BrandRole, "brand")
-        self.addRoleName(self.MaterialTypeRole, "material")
-        self.addRoleName(self.ColorNameRole, "color_name")
-        self.addRoleName(self.ColorCodeRole, "color_code")
-        self.addRoleName(self.ContainerNodeRole, "container_node")
-        self.addRoleName(self.ContainerIdRole, "container_id")
-
-        self.addRoleName(self.DescriptionRole, "description")
-        self.addRoleName(self.AdhesionInfoRole, "adhesion_info")
-        self.addRoleName(self.ApproximateDiameterRole, "approximate_diameter")
-        self.addRoleName(self.GuidRole, "guid")
-        self.addRoleName(self.DensityRole, "density")
-        self.addRoleName(self.DiameterRole, "diameter")
-        self.addRoleName(self.IsReadOnlyRole, "is_read_only")
-
-        from cura.CuraApplication import CuraApplication
-        self._container_registry = CuraApplication.getInstance().getContainerRegistry()
-        self._machine_manager = CuraApplication.getInstance().getMachineManager()
-        self._extruder_manager = CuraApplication.getInstance().getExtruderManager()
-        self._material_manager = CuraApplication.getInstance().getMaterialManager()
-
-        self._machine_manager.globalContainerChanged.connect(self._update)
-        self._extruder_manager.activeExtruderChanged.connect(self._update)
-        self._material_manager.materialsUpdated.connect(self._update)
-
-        self._update()
-
-    def _update(self):
-        Logger.log("d", "Updating {model_class_name}.".format(model_class_name = self.__class__.__name__))
-
-        global_stack = self._machine_manager.activeMachine
-        if global_stack is None:
-            self.setItems([])
-            return
-        active_extruder_stack = self._machine_manager.activeStack
-
-        available_material_dict = self._material_manager.getAvailableMaterialsForMachineExtruder(global_stack,
-                                                                                                 active_extruder_stack)
-        if available_material_dict is None:
-            self.setItems([])
-            return
-
-        material_list = []
-        for root_material_id, container_node in available_material_dict.items():
-            keys_to_fetch = ("name",
-                             "brand",
-                             "material",
-                             "color_name",
-                             "color_code",
-                             "description",
-                             "adhesion_info",
-                             "approximate_diameter",)
-
-            item = {"root_material_id": container_node.metadata["base_file"],
-                    "container_node": container_node,
-                    "guid": container_node.metadata["GUID"],
-                    "container_id": container_node.metadata["id"],
-                    "density": container_node.metadata.get("properties", {}).get("density", ""),
-                    "diameter": container_node.metadata.get("properties", {}).get("diameter", ""),
-                    "is_read_only": self._container_registry.isReadOnly(container_node.metadata["id"]),
-                    }
-
-            for key in keys_to_fetch:
-                item[key] = container_node.metadata.get(key, "")
-
-            material_list.append(item)
-
-        material_list = sorted(material_list, key = lambda k: (k["brand"].upper(), k["name"].upper()))
-        self.setItems(material_list)

cura/Machines/Models/MultiBuildPlateModel.py

@@ -4,6 +4,7 @@
 from PyQt5.QtCore import QTimer, pyqtSignal, pyqtProperty
 
 from UM.Application import Application
+from UM.Scene.Camera import Camera
 from UM.Scene.Selection import Selection
 from UM.Qt.ListModel import ListModel
 
@@ -34,8 +35,9 @@ class MultiBuildPlateModel(ListModel):
         self._active_build_plate = -1
 
     def setMaxBuildPlate(self, max_build_plate):
-        self._max_build_plate = max_build_plate
-        self.maxBuildPlateChanged.emit()
+        if self._max_build_plate != max_build_plate:
+            self._max_build_plate = max_build_plate
+            self.maxBuildPlateChanged.emit()
 
     ##  Return the highest build plate number
     @pyqtProperty(int, notify = maxBuildPlateChanged)
@@ -43,15 +45,17 @@ class MultiBuildPlateModel(ListModel):
         return self._max_build_plate
 
     def setActiveBuildPlate(self, nr):
-        self._active_build_plate = nr
-        self.activeBuildPlateChanged.emit()
+        if self._active_build_plate != nr:
+            self._active_build_plate = nr
+            self.activeBuildPlateChanged.emit()
 
     @pyqtProperty(int, notify = activeBuildPlateChanged)
     def activeBuildPlate(self):
         return self._active_build_plate
 
     def _updateSelectedObjectBuildPlateNumbersDelayed(self, *args):
-        self._update_timer.start()
+        if not isinstance(args[0], Camera):
+            self._update_timer.start()
 
     def _updateSelectedObjectBuildPlateNumbers(self, *args):
         result = set()

cura/Machines/Models/NozzleModel.py

@@ -33,8 +33,6 @@ class NozzleModel(ListModel):
     def _update(self):
         Logger.log("d", "Updating {model_class_name}.".format(model_class_name = self.__class__.__name__))
 
-        self.items.clear()
-
         global_stack = self._machine_manager.activeMachine
         if global_stack is None:
             self.setItems([])

cura/Machines/Models/QualityProfilesDropDownMenuModel.py

@@ -1,11 +1,12 @@
 # Copyright (c) 2018 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
 
-from PyQt5.QtCore import Qt
+from PyQt5.QtCore import Qt, QTimer
 
 from UM.Application import Application
 from UM.Logger import Logger
 from UM.Qt.ListModel import ListModel
+from UM.Settings.SettingFunction import SettingFunction
 
 from cura.Machines.QualityManager import QualityGroup
 
@@ -21,6 +22,7 @@ class QualityProfilesDropDownMenuModel(ListModel):
     AvailableRole = Qt.UserRole + 5
     QualityGroupRole = Qt.UserRole + 6
     QualityChangesGroupRole = Qt.UserRole + 7
+    IsExperimentalRole = Qt.UserRole + 8
 
     def __init__(self, parent = None):
         super().__init__(parent)
@@ -32,19 +34,28 @@ class QualityProfilesDropDownMenuModel(ListModel):
         self.addRoleName(self.AvailableRole, "available") #Whether the quality profile is available in our current nozzle + material.
         self.addRoleName(self.QualityGroupRole, "quality_group")
         self.addRoleName(self.QualityChangesGroupRole, "quality_changes_group")
+        self.addRoleName(self.IsExperimentalRole, "is_experimental")
 
         self._application = Application.getInstance()
         self._machine_manager = self._application.getMachineManager()
         self._quality_manager = Application.getInstance().getQualityManager()
 
-        self._application.globalContainerStackChanged.connect(self._update)
-        self._machine_manager.activeQualityGroupChanged.connect(self._update)
-        self._machine_manager.extruderChanged.connect(self._update)
-        self._quality_manager.qualitiesUpdated.connect(self._update)
+        self._application.globalContainerStackChanged.connect(self._onChange)
+        self._machine_manager.activeQualityGroupChanged.connect(self._onChange)
+        self._machine_manager.extruderChanged.connect(self._onChange)
+        self._quality_manager.qualitiesUpdated.connect(self._onChange)
 
         self._layer_height_unit = ""  # This is cached
 
-        self._update()
+        self._update_timer = QTimer()  # type: QTimer
+        self._update_timer.setInterval(100)
+        self._update_timer.setSingleShot(True)
+        self._update_timer.timeout.connect(self._update)
+
+        self._onChange()
+
+    def _onChange(self) -> None:
+        self._update_timer.start()
 
     def _update(self):
         Logger.log("d", "Updating {model_class_name}.".format(model_class_name = self.__class__.__name__))
@@ -74,7 +85,8 @@ class QualityProfilesDropDownMenuModel(ListModel):
                     "layer_height": layer_height,
                     "layer_height_unit": self._layer_height_unit,
                     "available": quality_group.is_available,
-                    "quality_group": quality_group}
+                    "quality_group": quality_group,
+                    "is_experimental": quality_group.is_experimental}
 
             item_list.append(item)
 
@@ -106,4 +118,8 @@ class QualityProfilesDropDownMenuModel(ListModel):
             container = global_stack.definition
             if container and container.hasProperty("layer_height", "value"):
                 layer_height = container.getProperty("layer_height", "value")
+
+        if isinstance(layer_height, SettingFunction):
+            layer_height = layer_height(global_stack)
+
         return float(layer_height)

cura/Machines/Models/SettingVisibilityPresetsModel.py

@@ -1,135 +1,115 @@
 # Copyright (c) 2018 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
 
-from typing import Optional
-import os
-import urllib.parse
-from configparser import ConfigParser
+from typing import Optional, List
 
-from PyQt5.QtCore import pyqtProperty, Qt, pyqtSignal, pyqtSlot
+from PyQt5.QtCore import pyqtProperty, pyqtSignal, pyqtSlot, QObject
 
-from UM.Application import Application
 from UM.Logger import Logger
-from UM.Qt.ListModel import ListModel
+from UM.Preferences import Preferences
 from UM.Resources import Resources
-from UM.MimeTypeDatabase import MimeTypeDatabase, MimeTypeNotFoundError
 
 from UM.i18n import i18nCatalog
+from cura.Settings.SettingVisibilityPreset import SettingVisibilityPreset
+
 catalog = i18nCatalog("cura")
 
 
-class SettingVisibilityPresetsModel(ListModel):
-    IdRole = Qt.UserRole + 1
-    NameRole = Qt.UserRole + 2
-    SettingsRole = Qt.UserRole + 3
+class SettingVisibilityPresetsModel(QObject):
+    onItemsChanged = pyqtSignal()
+    activePresetChanged = pyqtSignal()
 
-    def __init__(self, parent = None):
+    def __init__(self, preferences: Preferences, parent = None) -> None:
         super().__init__(parent)
-        self.addRoleName(self.IdRole, "id")
-        self.addRoleName(self.NameRole, "name")
-        self.addRoleName(self.SettingsRole, "settings")
+
+        self._items = []  # type: List[SettingVisibilityPreset]
+        self._custom_preset = SettingVisibilityPreset(preset_id = "custom", name = "Custom selection", weight = -100)
 
         self._populate()
-        basic_item = self.items[1]
-        basic_visibile_settings = ";".join(basic_item["settings"])
 
-        self._preferences = Application.getInstance().getPreferences()
+        basic_item = self.getVisibilityPresetById("basic")
+        if basic_item is not None:
+            basic_visibile_settings = ";".join(basic_item.settings)
+        else:
+            Logger.log("w", "Unable to find the basic visiblity preset.")
+            basic_visibile_settings = ""
+
+        self._preferences = preferences
+
         # Preference to store which preset is currently selected
         self._preferences.addPreference("cura/active_setting_visibility_preset", "basic")
+
         # Preference that stores the "custom" set so it can always be restored (even after a restart)
         self._preferences.addPreference("cura/custom_visible_settings", basic_visibile_settings)
         self._preferences.preferenceChanged.connect(self._onPreferencesChanged)
 
-        self._active_preset_item = self._getItem(self._preferences.getValue("cura/active_setting_visibility_preset"))
+        self._active_preset_item = self.getVisibilityPresetById(self._preferences.getValue("cura/active_setting_visibility_preset"))
+
         # Initialize visible settings if it is not done yet
         visible_settings = self._preferences.getValue("general/visible_settings")
+
         if not visible_settings:
-            self._preferences.setValue("general/visible_settings", ";".join(self._active_preset_item["settings"]))
+            new_visible_settings = self._active_preset_item.settings if self._active_preset_item is not None else []
+            self._preferences.setValue("general/visible_settings", ";".join(new_visible_settings))
         else:
             self._onPreferencesChanged("general/visible_settings")
 
         self.activePresetChanged.emit()
 
-    def _getItem(self, item_id: str) -> Optional[dict]:
+    def getVisibilityPresetById(self, item_id: str) -> Optional[SettingVisibilityPreset]:
         result = None
-        for item in self.items:
-            if item["id"] == item_id:
+        for item in self._items:
+            if item.presetId == item_id:
                 result = item
                 break
         return result
 
-    def _populate(self):
+    def _populate(self) -> None:
         from cura.CuraApplication import CuraApplication
-        items = []
+        items = []  # type: List[SettingVisibilityPreset]
+        items.append(self._custom_preset)
         for file_path in Resources.getAllResourcesOfType(CuraApplication.ResourceTypes.SettingVisibilityPreset):
+            setting_visibility_preset = SettingVisibilityPreset()
             try:
-                mime_type = MimeTypeDatabase.getMimeTypeForFile(file_path)
-            except MimeTypeNotFoundError:
-                Logger.log("e", "Could not determine mime type of file %s", file_path)
-                continue
-
-            item_id = urllib.parse.unquote_plus(mime_type.stripExtension(os.path.basename(file_path)))
-            if not os.path.isfile(file_path):
-                Logger.log("e", "[%s] is not a file", file_path)
-                continue
-
-            parser = ConfigParser(allow_no_value = True)  # accept options without any value,
-            try:
-                parser.read([file_path])
-                if not parser.has_option("general", "name") or not parser.has_option("general", "weight"):
-                    continue
-
-                settings = []
-                for section in parser.sections():
-                    if section == 'general':
-                        continue
-
-                    settings.append(section)
-                    for option in parser[section].keys():
-                        settings.append(option)
-
-                items.append({
-                    "id": item_id,
-                    "name": catalog.i18nc("@action:inmenu", parser["general"]["name"]),
-                    "weight": parser["general"]["weight"],
-                    "settings": settings,
-                })
-
+                setting_visibility_preset.loadFromFile(file_path)
             except Exception:
                 Logger.logException("e", "Failed to load setting preset %s", file_path)
 
-        items.sort(key = lambda k: (int(k["weight"]), k["id"]))
-        # Put "custom" at the top
-        items.insert(0, {"id": "custom",
-                         "name": "Custom selection",
-                         "weight": -100,
-                         "settings": []})
+            items.append(setting_visibility_preset)
+
+        # Sort them on weight (and if that fails, use ID)
+        items.sort(key = lambda k: (int(k.weight), k.presetId))
 
         self.setItems(items)
 
+    @pyqtProperty("QVariantList", notify = onItemsChanged)
+    def items(self) -> List[SettingVisibilityPreset]:
+        return self._items
+
+    def setItems(self, items: List[SettingVisibilityPreset]) -> None:
+        if self._items != items:
+            self._items = items
+            self.onItemsChanged.emit()
+
     @pyqtSlot(str)
-    def setActivePreset(self, preset_id: str):
-        if preset_id == self._active_preset_item["id"]:
+    def setActivePreset(self, preset_id: str) -> None:
+        if self._active_preset_item is not None and preset_id == self._active_preset_item.presetId:
             Logger.log("d", "Same setting visibility preset [%s] selected, do nothing.", preset_id)
             return
 
-        preset_item = None
-        for item in self.items:
-            if item["id"] == preset_id:
-                preset_item = item
-                break
+        preset_item = self.getVisibilityPresetById(preset_id)
         if preset_item is None:
             Logger.log("w", "Tried to set active preset to unknown id [%s]", preset_id)
             return
 
-        need_to_save_to_custom = self._active_preset_item["id"] == "custom" and preset_id != "custom"
+        need_to_save_to_custom = self._active_preset_item is None or (self._active_preset_item.presetId == "custom" and preset_id != "custom")
         if need_to_save_to_custom:
             # Save the current visibility settings to custom
             current_visibility_string = self._preferences.getValue("general/visible_settings")
             if current_visibility_string:
                 self._preferences.setValue("cura/custom_visible_settings", current_visibility_string)
 
-        new_visibility_string = ";".join(preset_item["settings"])
+        new_visibility_string = ";".join(preset_item.settings)
         if preset_id == "custom":
             # Get settings from the stored custom data
             new_visibility_string = self._preferences.getValue("cura/custom_visible_settings")
@@ -141,13 +121,13 @@ class SettingVisibilityPresetsModel(ListModel):
         self._active_preset_item = preset_item
         self.activePresetChanged.emit()
 
-    activePresetChanged = pyqtSignal()
-
     @pyqtProperty(str, notify = activePresetChanged)
     def activePreset(self) -> str:
-        return self._active_preset_item["id"]
+        if self._active_preset_item is not None:
+            return self._active_preset_item.presetId
+        return ""
 
-    def _onPreferencesChanged(self, name: str):
+    def _onPreferencesChanged(self, name: str) -> None:
         if name != "general/visible_settings":
             return
 
@@ -158,25 +138,31 @@ class SettingVisibilityPresetsModel(ListModel):
 
         visibility_set = set(visibility_string.split(";"))
         matching_preset_item = None
-        for item in self.items:
-            if item["id"] == "custom":
+        for item in self._items:
+            if item.presetId == "custom":
                 continue
-            if set(item["settings"]) == visibility_set:
+            if set(item.settings) == visibility_set:
                 matching_preset_item = item
                 break
 
         item_to_set = self._active_preset_item
         if matching_preset_item is None:
             # The new visibility setup is "custom" should be custom
-            if self._active_preset_item["id"] == "custom":
+            if self._active_preset_item is None or self._active_preset_item.presetId == "custom":
                 # We are already in custom, just save the settings
                 self._preferences.setValue("cura/custom_visible_settings", visibility_string)
             else:
-                item_to_set = self.items[0]  # 0 is custom
+                # We need to move to custom preset.
+                item_to_set = self.getVisibilityPresetById("custom")
         else:
             item_to_set = matching_preset_item
 
-        if self._active_preset_item is None or self._active_preset_item["id"] != item_to_set["id"]:
+        # If we didn't find a matching preset, fallback to custom.
+        if item_to_set is None:
+            item_to_set = self._custom_preset
+
+        if self._active_preset_item is None or self._active_preset_item.presetId != item_to_set.presetId:
             self._active_preset_item = item_to_set
-            self._preferences.setValue("cura/active_setting_visibility_preset", self._active_preset_item["id"])
+            if self._active_preset_item is not None:
+                self._preferences.setValue("cura/active_setting_visibility_preset", self._active_preset_item.presetId)
             self.activePresetChanged.emit()

cura/Machines/QualityChangesGroup.py

@@ -17,16 +17,16 @@ class QualityChangesGroup(QualityGroup):
         super().__init__(name, quality_type, parent)
         self._container_registry = Application.getInstance().getContainerRegistry()
 
-    def addNode(self, node: "QualityNode"):
+    def addNode(self, node: "QualityNode") -> None:
         extruder_position = node.getMetaDataEntry("position")
 
         if extruder_position is None and self.node_for_global is not None or extruder_position in self.nodes_for_extruders: #We would be overwriting another node.
             ConfigurationErrorMessage.getInstance().addFaultyContainers(node.getMetaDataEntry("id"))
             return
 
-        if extruder_position is None: #Then we're a global quality changes profile.
+        if extruder_position is None:  # Then we're a global quality changes profile.
             self.node_for_global = node
-        else: #This is an extruder's quality changes profile.
+        else:  # This is an extruder's quality changes profile.
             self.nodes_for_extruders[extruder_position] = node
 
     def __str__(self) -> str:

cura/Machines/QualityGroup.py

@@ -4,8 +4,12 @@
 from typing import Dict, Optional, List, Set
 
 from PyQt5.QtCore import QObject, pyqtSlot
+
+from UM.Util import parseBool
+
 from cura.Machines.ContainerNode import ContainerNode
 
+
 #
 # A QualityGroup represents a group of containers that must be applied to each ContainerStack when it's used.
 # Some concrete examples are Quality and QualityChanges: when we select quality type "normal", this quality type
@@ -28,13 +32,14 @@ class QualityGroup(QObject):
         self.nodes_for_extruders = {}  # type: Dict[int, ContainerNode]
         self.quality_type = quality_type
         self.is_available = False
+        self.is_experimental = False
 
     @pyqtSlot(result = str)
     def getName(self) -> str:
         return self.name
 
     def getAllKeys(self) -> Set[str]:
-        result = set() #type: Set[str]
+        result = set()  # type: Set[str]
         for node in [self.node_for_global] + list(self.nodes_for_extruders.values()):
             if node is None:
                 continue
@@ -50,3 +55,17 @@ class QualityGroup(QObject):
         for extruder_node in self.nodes_for_extruders.values():
             result.append(extruder_node)
         return result
+
+    def setGlobalNode(self, node: "ContainerNode") -> None:
+        self.node_for_global = node
+
+        # Update is_experimental flag
+        is_experimental = parseBool(node.getMetaDataEntry("is_experimental", False))
+        self.is_experimental |= is_experimental
+
+    def setExtruderNode(self, position: int, node: "ContainerNode") -> None:
+        self.nodes_for_extruders[position] = node
+
+        # Update is_experimental flag
+        is_experimental = parseBool(node.getMetaDataEntry("is_experimental", False))
+        self.is_experimental |= is_experimental

cura/Machines/QualityManager.py

@@ -1,11 +1,10 @@
 # Copyright (c) 2018 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
 
-from typing import TYPE_CHECKING, Optional, cast
+from typing import TYPE_CHECKING, Optional, cast, Dict, List, Set
 
 from PyQt5.QtCore import QObject, QTimer, pyqtSignal, pyqtSlot
 
-from UM.Application import Application
 from UM.ConfigurationErrorMessage import ConfigurationErrorMessage
 from UM.Logger import Logger
 from UM.Util import parseBool
@@ -17,9 +16,10 @@ from .QualityGroup import QualityGroup
 from .QualityNode import QualityNode
 
 if TYPE_CHECKING:
-    from UM.Settings.DefinitionContainer import DefinitionContainer
+    from UM.Settings.Interfaces import DefinitionContainerInterface
     from cura.Settings.GlobalStack import GlobalStack
     from .QualityChangesGroup import QualityChangesGroup
+    from cura.CuraApplication import CuraApplication
 
 
 #
@@ -36,17 +36,20 @@ class QualityManager(QObject):
 
     qualitiesUpdated = pyqtSignal()
 
-    def __init__(self, container_registry, parent = None):
+    def __init__(self, application: "CuraApplication", parent = None) -> None:
         super().__init__(parent)
-        self._application = Application.getInstance()
+        self._application = application
         self._material_manager = self._application.getMaterialManager()
-        self._container_registry = container_registry
+        self._container_registry = self._application.getContainerRegistry()
 
         self._empty_quality_container = self._application.empty_quality_container
         self._empty_quality_changes_container = self._application.empty_quality_changes_container
 
-        self._machine_nozzle_buildplate_material_quality_type_to_quality_dict = {}  # for quality lookup
-        self._machine_quality_type_to_quality_changes_dict = {}  # for quality_changes lookup
+        # For quality lookup
+        self._machine_nozzle_buildplate_material_quality_type_to_quality_dict = {}  # type: Dict[str, QualityNode]
+
+        # For quality_changes lookup
+        self._machine_quality_type_to_quality_changes_dict = {}  # type: Dict[str, QualityNode]
 
         self._default_machine_definition_id = "fdmprinter"
 
@@ -62,7 +65,7 @@ class QualityManager(QObject):
         self._update_timer.setSingleShot(True)
         self._update_timer.timeout.connect(self._updateMaps)
 
-    def initialize(self):
+    def initialize(self) -> None:
         # Initialize the lookup tree for quality profiles with following structure:
         # <machine> -> <nozzle> -> <buildplate> -> <material>
         # <machine> -> <material>
@@ -133,13 +136,13 @@ class QualityManager(QObject):
         Logger.log("d", "Lookup tables updated.")
         self.qualitiesUpdated.emit()
 
-    def _updateMaps(self):
+    def _updateMaps(self) -> None:
         self.initialize()
 
-    def _onContainerMetadataChanged(self, container):
+    def _onContainerMetadataChanged(self, container: InstanceContainer) -> None:
         self._onContainerChanged(container)
 
-    def _onContainerChanged(self, container):
+    def _onContainerChanged(self, container: InstanceContainer) -> None:
         container_type = container.getMetaDataEntry("type")
         if container_type not in ("quality", "quality_changes"):
             return
@@ -148,7 +151,7 @@ class QualityManager(QObject):
         self._update_timer.start()
 
     # Updates the given quality groups' availabilities according to which extruders are being used/ enabled.
-    def _updateQualityGroupsAvailability(self, machine: "GlobalStack", quality_group_list):
+    def _updateQualityGroupsAvailability(self, machine: "GlobalStack", quality_group_list) -> None:
         used_extruders = set()
         for i in range(machine.getProperty("machine_extruder_count", "value")):
             if str(i) in machine.extruders and machine.extruders[str(i)].isEnabled:
@@ -196,33 +199,43 @@ class QualityManager(QObject):
     # Whether a QualityGroup is available can be unknown via the field QualityGroup.is_available.
     # For more details, see QualityGroup.
     #
-    def getQualityGroups(self, machine: "GlobalStack") -> dict:
+    def getQualityGroups(self, machine: "GlobalStack") -> Dict[str, QualityGroup]:
         machine_definition_id = getMachineDefinitionIDForQualitySearch(machine.definition)
 
         # This determines if we should only get the global qualities for the global stack and skip the global qualities for the extruder stacks
-        has_variant_materials = parseBool(machine.getMetaDataEntry("has_variant_materials", False))
+        has_machine_specific_qualities = machine.getHasMachineQuality()
 
         # To find the quality container for the GlobalStack, check in the following fall-back manner:
         #   (1) the machine-specific node
         #   (2) the generic node
         machine_node = self._machine_nozzle_buildplate_material_quality_type_to_quality_dict.get(machine_definition_id)
+        # Check if this machine has specific quality profiles for its extruders, if so, when looking up extruder
+        # qualities, we should not fall back to use the global qualities.
+        has_extruder_specific_qualities = False
+        if machine_node:
+            if machine_node.children_map:
+                has_extruder_specific_qualities = True
+
         default_machine_node = self._machine_nozzle_buildplate_material_quality_type_to_quality_dict.get(self._default_machine_definition_id)
-        nodes_to_check = [machine_node, default_machine_node]
+
+        nodes_to_check = []  # type: List[QualityNode]
+        if machine_node is not None:
+            nodes_to_check.append(machine_node)
+        if default_machine_node is not None:
+            nodes_to_check.append(default_machine_node)
 
         # Iterate over all quality_types in the machine node
         quality_group_dict = {}
         for node in nodes_to_check:
             if node and node.quality_type_map:
-                # Only include global qualities
-                if has_variant_materials:
-                    quality_node = list(node.quality_type_map.values())[0]
-                    is_global_quality = parseBool(quality_node.metadata.get("global_quality", False))
-                    if not is_global_quality:
-                        continue
+                quality_node = list(node.quality_type_map.values())[0]
+                is_global_quality = parseBool(quality_node.getMetaDataEntry("global_quality", False))
+                if not is_global_quality:
+                    continue
 
                 for quality_type, quality_node in node.quality_type_map.items():
-                    quality_group = QualityGroup(quality_node.metadata["name"], quality_type)
-                    quality_group.node_for_global = quality_node
+                    quality_group = QualityGroup(quality_node.getMetaDataEntry("name", ""), quality_type)
+                    quality_group.setGlobalNode(quality_node)
                     quality_group_dict[quality_type] = quality_group
                 break
 
@@ -246,11 +259,15 @@ class QualityManager(QObject):
                 root_material_id = self._material_manager.getRootMaterialIDWithoutDiameter(root_material_id)
                 root_material_id_list.append(root_material_id)
 
-                # Also try to get the fallback material
-                material_type = extruder.material.getMetaDataEntry("material")
-                fallback_root_material_id = self._material_manager.getFallbackMaterialIdByMaterialType(material_type)
-                if fallback_root_material_id:
-                    root_material_id_list.append(fallback_root_material_id)
+                # Also try to get the fallback materials
+                fallback_ids = self._material_manager.getFallBackMaterialIdsByMaterial(extruder.material)
+
+                if fallback_ids:
+                    root_material_id_list.extend(fallback_ids)
+
+                # Weed out duplicates while preserving the order.
+                seen = set()  # type: Set[str]
+                root_material_id_list = [x for x in root_material_id_list if x not in seen and not seen.add(x)]  # type: ignore
 
             # Here we construct a list of nodes we want to look for qualities with the highest priority first.
             # The use case is that, when we look for qualities for a machine, we first want to search in the following
@@ -259,18 +276,25 @@ class QualityManager(QObject):
             #   2. machine-nozzle-and-material-specific qualities if exist
             #   3. machine-nozzle-specific qualities if exist
             #   4. machine-material-specific qualities if exist
-            #   5. machine-specific qualities if exist
-            #   6. generic qualities if exist
+            #   5. machine-specific global qualities if exist, otherwise generic global qualities
+            #      NOTE: We DO NOT fail back to generic global qualities if machine-specific global qualities exist.
+            #            This is because when a machine defines its own global qualities such as Normal, Fine, etc.,
+            #            it is intended to maintain those specific qualities ONLY. If we still fail back to the generic
+            #            global qualities, there can be unimplemented quality types e.g. "coarse", and this is not
+            #            correct.
             # Each points above can be represented as a node in the lookup tree, so here we simply put those nodes into
             # the list with priorities as the order. Later, we just need to loop over each node in this list and fetch
             # qualities from there.
-            node_info_list_0 = [nozzle_name, buildplate_name, root_material_id]
+            node_info_list_0 = [nozzle_name, buildplate_name, root_material_id]  # type: List[Optional[str]]
             nodes_to_check = []
 
             # This function tries to recursively find the deepest (the most specific) branch and add those nodes to
             # the search list in the order described above. So, by iterating over that search node list, we first look
             # in the more specific branches and then the less specific (generic) ones.
-            def addNodesToCheck(node, nodes_to_check_list, node_info_list, node_info_idx):
+            def addNodesToCheck(node: Optional[QualityNode], nodes_to_check_list: List[QualityNode], node_info_list, node_info_idx: int) -> None:
+                if node is None:
+                    return
+
                 if node_info_idx < len(node_info_list):
                     node_name = node_info_list[node_info_idx]
                     if node_name is not None:
@@ -289,31 +313,44 @@ class QualityManager(QObject):
 
             addNodesToCheck(machine_node, nodes_to_check, node_info_list_0, 0)
 
-            nodes_to_check += [machine_node, default_machine_node]
-            for node in nodes_to_check:
+            # The last fall back will be the global qualities (either from the machine-specific node or the generic
+            # node), but we only use one. For details see the overview comments above.
+
+            if machine_node is not None and machine_node.quality_type_map:
+                nodes_to_check += [machine_node]
+            elif default_machine_node is not None:
+                nodes_to_check += [default_machine_node]
+
+            for node_idx, node in enumerate(nodes_to_check):
                 if node and node.quality_type_map:
-                    if has_variant_materials:
+                    if has_extruder_specific_qualities:
                         # Only include variant qualities; skip non global qualities
                         quality_node = list(node.quality_type_map.values())[0]
-                        is_global_quality = parseBool(quality_node.metadata.get("global_quality", False))
+                        is_global_quality = parseBool(quality_node.getMetaDataEntry("global_quality", False))
                         if is_global_quality:
                             continue
 
                     for quality_type, quality_node in node.quality_type_map.items():
                         if quality_type not in quality_group_dict:
-                            quality_group = QualityGroup(quality_node.metadata["name"], quality_type)
+                            quality_group = QualityGroup(quality_node.getMetaDataEntry("name", ""), quality_type)
                             quality_group_dict[quality_type] = quality_group
 
                         quality_group = quality_group_dict[quality_type]
                         if position not in quality_group.nodes_for_extruders:
-                            quality_group.nodes_for_extruders[position] = quality_node
+                            quality_group.setExtruderNode(position, quality_node)
+
+                # If the machine has its own specific qualities, for extruders, it should skip the global qualities
+                # and use the material/variant specific qualities.
+                if has_extruder_specific_qualities:
+                    if node_idx == len(nodes_to_check) - 1:
+                        break
 
         # Update availabilities for each quality group
         self._updateQualityGroupsAvailability(machine, quality_group_dict.values())
 
         return quality_group_dict
 
-    def getQualityGroupsForMachineDefinition(self, machine: "GlobalStack") -> dict:
+    def getQualityGroupsForMachineDefinition(self, machine: "GlobalStack") -> Dict[str, QualityGroup]:
         machine_definition_id = getMachineDefinitionIDForQualitySearch(machine.definition)
 
         # To find the quality container for the GlobalStack, check in the following fall-back manner:
@@ -329,8 +366,8 @@ class QualityManager(QObject):
         for node in nodes_to_check:
             if node and node.quality_type_map:
                 for quality_type, quality_node in node.quality_type_map.items():
-                    quality_group = QualityGroup(quality_node.metadata["name"], quality_type)
-                    quality_group.node_for_global = quality_node
+                    quality_group = QualityGroup(quality_node.getMetaDataEntry("name", ""), quality_type)
+                    quality_group.setGlobalNode(quality_node)
                     quality_group_dict[quality_type] = quality_group
                 break
 
@@ -351,10 +388,21 @@ class QualityManager(QObject):
     # Remove the given quality changes group.
     #
     @pyqtSlot(QObject)
-    def removeQualityChangesGroup(self, quality_changes_group: "QualityChangesGroup"):
+    def removeQualityChangesGroup(self, quality_changes_group: "QualityChangesGroup") -> None:
         Logger.log("i", "Removing quality changes group [%s]", quality_changes_group.name)
+        removed_quality_changes_ids = set()
         for node in quality_changes_group.getAllNodes():
-            self._container_registry.removeContainer(node.getMetaDataEntry("id"))
+            container_id = node.getMetaDataEntry("id")
+            self._container_registry.removeContainer(container_id)
+            removed_quality_changes_ids.add(container_id)
+
+        # Reset all machines that have activated this quality changes to empty.
+        for global_stack in self._container_registry.findContainerStacks(type = "machine"):
+            if global_stack.qualityChanges.getId() in removed_quality_changes_ids:
+                global_stack.qualityChanges = self._empty_quality_changes_container
+        for extruder_stack in self._container_registry.findContainerStacks(type = "extruder_train"):
+            if extruder_stack.qualityChanges.getId() in removed_quality_changes_ids:
+                extruder_stack.qualityChanges = self._empty_quality_changes_container
 
     #
     # Rename a set of quality changes containers. Returns the new name.
@@ -383,7 +431,7 @@ class QualityManager(QObject):
     # Duplicates the given quality.
     #
     @pyqtSlot(str, "QVariantMap")
-    def duplicateQualityChanges(self, quality_changes_name, quality_model_item):
+    def duplicateQualityChanges(self, quality_changes_name: str, quality_model_item) -> None:
         global_stack = self._application.getGlobalContainerStack()
         if not global_stack:
             Logger.log("i", "No active global stack, cannot duplicate quality changes.")
@@ -411,8 +459,8 @@ class QualityManager(QObject):
     #   the user containers in each stack. These then replace the quality_changes containers in the
     #   stack and clear the user settings.
     @pyqtSlot(str)
-    def createQualityChanges(self, base_name):
-        machine_manager = Application.getInstance().getMachineManager()
+    def createQualityChanges(self, base_name: str) -> None:
+        machine_manager = self._application.getMachineManager()
 
         global_stack = machine_manager.activeMachine
         if not global_stack:
@@ -490,7 +538,7 @@ class QualityManager(QObject):
 #      Example: for an Ultimaker 3 Extended, it has "quality_definition = ultimaker3". This means Ultimaker 3 Extended
 #               shares the same set of qualities profiles as Ultimaker 3.
 #
-def getMachineDefinitionIDForQualitySearch(machine_definition: "DefinitionContainer",
+def getMachineDefinitionIDForQualitySearch(machine_definition: "DefinitionContainerInterface",
                                            default_definition_id: str = "fdmprinter") -> str:
     machine_definition_id = default_definition_id
     if parseBool(machine_definition.getMetaDataEntry("has_machine_quality", False)):

cura/Machines/QualityNode.py

@@ -1,7 +1,7 @@
 # Copyright (c) 2018 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
 
-from typing import Optional, Dict, cast
+from typing import Optional, Dict, cast, Any
 
 from .ContainerNode import ContainerNode
 from .QualityChangesGroup import QualityChangesGroup
@@ -12,18 +12,21 @@ from .QualityChangesGroup import QualityChangesGroup
 #
 class QualityNode(ContainerNode):
 
-    def __init__(self, metadata: Optional[dict] = None) -> None:
+    def __init__(self, metadata: Optional[Dict[str, Any]] = None) -> None:
         super().__init__(metadata = metadata)
         self.quality_type_map = {}  # type: Dict[str, QualityNode] # quality_type -> QualityNode for InstanceContainer
 
-    def addQualityMetadata(self, quality_type: str, metadata: dict):
+    def getChildNode(self, child_key: str) -> Optional["QualityNode"]:
+        return self.children_map.get(child_key)
+
+    def addQualityMetadata(self, quality_type: str, metadata: Dict[str, Any]):
         if quality_type not in self.quality_type_map:
             self.quality_type_map[quality_type] = QualityNode(metadata)
 
     def getQualityNode(self, quality_type: str) -> Optional["QualityNode"]:
         return self.quality_type_map.get(quality_type)
 
-    def addQualityChangesMetadata(self, quality_type: str, metadata: dict):
+    def addQualityChangesMetadata(self, quality_type: str, metadata: Dict[str, Any]):
         if quality_type not in self.quality_type_map:
             self.quality_type_map[quality_type] = QualityNode()
         quality_type_node = self.quality_type_map[quality_type]

cura/Machines/VariantManager.py

@@ -2,7 +2,7 @@
 # Cura is released under the terms of the LGPLv3 or higher.
 
 from collections import OrderedDict
-from typing import Optional, TYPE_CHECKING
+from typing import Optional, TYPE_CHECKING, Dict
 
 from UM.ConfigurationErrorMessage import ConfigurationErrorMessage
 from UM.Logger import Logger
@@ -36,11 +36,11 @@ if TYPE_CHECKING:
 #
 class VariantManager:
 
-    def __init__(self, container_registry):
-        self._container_registry = container_registry  # type: ContainerRegistry
+    def __init__(self, container_registry: ContainerRegistry) -> None:
+        self._container_registry = container_registry
 
-        self._machine_to_variant_dict_map = dict()  # <machine_type> -> <variant_dict>
-        self._machine_to_buildplate_dict_map = dict()
+        self._machine_to_variant_dict_map = dict()  # type: Dict[str, Dict["VariantType", Dict[str, ContainerNode]]]
+        self._machine_to_buildplate_dict_map = dict() # type: Dict[str, Dict[str, ContainerNode]]
 
         self._exclude_variant_id_list = ["empty_variant"]
 
@@ -48,7 +48,7 @@ class VariantManager:
     # Initializes the VariantManager including:
     #  - initializing the variant lookup table based on the metadata in ContainerRegistry.
     #
-    def initialize(self):
+    def initialize(self) -> None:
         self._machine_to_variant_dict_map = OrderedDict()
         self._machine_to_buildplate_dict_map = OrderedDict()
 
@@ -106,26 +106,33 @@ class VariantManager:
                     variant_node = variant_dict[variant_name]
                     break
             return variant_node
-        return self._machine_to_variant_dict_map[machine_definition_id].get(variant_type, {}).get(variant_name)
 
-    def getVariantNodes(self, machine: "GlobalStack",
-                        variant_type: Optional["VariantType"] = None) -> dict:
+        return self._machine_to_variant_dict_map.get(machine_definition_id, {}).get(variant_type, {}).get(variant_name)
+
+    def getVariantNodes(self, machine: "GlobalStack", variant_type: "VariantType") -> Dict[str, ContainerNode]:
         machine_definition_id = machine.definition.getId()
         return self._machine_to_variant_dict_map.get(machine_definition_id, {}).get(variant_type, {})
 
     #
     # Gets the default variant for the given machine definition.
+    # If the optional GlobalStack is given, the metadata information will be fetched from the GlobalStack instead of
+    # the DefinitionContainer. Because for machines such as UM2, you can enable Olsson Block, which will set
+    # "has_variants" to True in the GlobalStack. In those cases, we need to fetch metadata from the GlobalStack or
+    # it may not be correct.
     #
     def getDefaultVariantNode(self, machine_definition: "DefinitionContainer",
-                              variant_type: VariantType) -> Optional["ContainerNode"]:
+                              variant_type: "VariantType",
+                              global_stack: Optional["GlobalStack"] = None) -> Optional["ContainerNode"]:
         machine_definition_id = machine_definition.getId()
+        container_for_metadata_fetching = global_stack if global_stack is not None else machine_definition
+
         preferred_variant_name = None
         if variant_type == VariantType.BUILD_PLATE:
-            if parseBool(machine_definition.getMetaDataEntry("has_variant_buildplates", False)):
-                preferred_variant_name = machine_definition.getMetaDataEntry("preferred_variant_buildplate_name")
+            if parseBool(container_for_metadata_fetching.getMetaDataEntry("has_variant_buildplates", False)):
+                preferred_variant_name = container_for_metadata_fetching.getMetaDataEntry("preferred_variant_buildplate_name")
         else:
-            if parseBool(machine_definition.getMetaDataEntry("has_variants", False)):
-                preferred_variant_name = machine_definition.getMetaDataEntry("preferred_variant_name")
+            if parseBool(container_for_metadata_fetching.getMetaDataEntry("has_variants", False)):
+                preferred_variant_name = container_for_metadata_fetching.getMetaDataEntry("preferred_variant_name")
 
         node = None
         if preferred_variant_name:

cura/MultiplyObjectsJob.py

@@ -25,7 +25,7 @@ class MultiplyObjectsJob(Job):
 
     def run(self):
         status_message = Message(i18n_catalog.i18nc("@info:status", "Multiplying and placing objects"), lifetime=0,
-                                 dismissable=False, progress=0, title = i18n_catalog.i18nc("@info:title", "Placing Object"))
+                                 dismissable=False, progress=0, title = i18n_catalog.i18nc("@info:title", "Placing Objects"))
         status_message.show()
         scene = Application.getInstance().getController().getScene()
 

cura/OAuth2/AuthorizationHelpers.py

@@ -0,0 +1,122 @@
+# Copyright (c) 2019 Ultimaker B.V.
+# Cura is released under the terms of the LGPLv3 or higher.
+from datetime import datetime
+import json
+import random
+from hashlib import sha512
+from base64 import b64encode
+from typing import Optional
+
+import requests
+
+from UM.i18n import i18nCatalog
+from UM.Logger import Logger
+
+from cura.OAuth2.Models import AuthenticationResponse, UserProfile, OAuth2Settings
+catalog = i18nCatalog("cura")
+TOKEN_TIMESTAMP_FORMAT = "%Y-%m-%d %H:%M:%S"
+
+##  Class containing several helpers to deal with the authorization flow.
+class AuthorizationHelpers:
+    def __init__(self, settings: "OAuth2Settings") -> None:
+        self._settings = settings
+        self._token_url = "{}/token".format(self._settings.OAUTH_SERVER_URL)
+
+    @property
+    ##  The OAuth2 settings object.
+    def settings(self) -> "OAuth2Settings":
+        return self._settings
+
+    ##  Request the access token from the authorization server.
+    #   \param authorization_code: The authorization code from the 1st step.
+    #   \param verification_code: The verification code needed for the PKCE
+    #   extension.
+    #   \return An AuthenticationResponse object.
+    def getAccessTokenUsingAuthorizationCode(self, authorization_code: str, verification_code: str) -> "AuthenticationResponse":
+        data = {
+            "client_id": self._settings.CLIENT_ID if self._settings.CLIENT_ID is not None else "",
+            "redirect_uri": self._settings.CALLBACK_URL if self._settings.CALLBACK_URL is not None else "",
+            "grant_type": "authorization_code",
+            "code": authorization_code,
+            "code_verifier": verification_code,
+            "scope": self._settings.CLIENT_SCOPES if self._settings.CLIENT_SCOPES is not None else "",
+            }
+        return self.parseTokenResponse(requests.post(self._token_url, data = data))  # type: ignore
+
+    ##  Request the access token from the authorization server using a refresh token.
+    #   \param refresh_token:
+    #   \return An AuthenticationResponse object.
+    def getAccessTokenUsingRefreshToken(self, refresh_token: str) -> "AuthenticationResponse":
+        data = {
+            "client_id": self._settings.CLIENT_ID if self._settings.CLIENT_ID is not None else "",
+            "redirect_uri": self._settings.CALLBACK_URL if self._settings.CALLBACK_URL is not None else "",
+            "grant_type": "refresh_token",
+            "refresh_token": refresh_token,
+            "scope": self._settings.CLIENT_SCOPES if self._settings.CLIENT_SCOPES is not None else "",
+        }
+        return self.parseTokenResponse(requests.post(self._token_url, data = data))  # type: ignore
+
+    @staticmethod
+    ##  Parse the token response from the authorization server into an AuthenticationResponse object.
+    #   \param token_response: The JSON string data response from the authorization server.
+    #   \return An AuthenticationResponse object.
+    def parseTokenResponse(token_response: requests.models.Response) -> "AuthenticationResponse":
+        token_data = None
+
+        try:
+            token_data = json.loads(token_response.text)
+        except ValueError:
+            Logger.log("w", "Could not parse token response data: %s", token_response.text)
+
+        if not token_data:
+            return AuthenticationResponse(success = False, err_message = catalog.i18nc("@message", "Could not read response."))
+
+        if token_response.status_code not in (200, 201):
+            return AuthenticationResponse(success = False, err_message = token_data["error_description"])
+
+        return AuthenticationResponse(success=True,
+                                      token_type=token_data["token_type"],
+                                      access_token=token_data["access_token"],
+                                      refresh_token=token_data["refresh_token"],
+                                      expires_in=token_data["expires_in"],
+                                      scope=token_data["scope"],
+                                      received_at=datetime.now().strftime(TOKEN_TIMESTAMP_FORMAT))
+
+    ##  Calls the authentication API endpoint to get the token data.
+    #   \param access_token: The encoded JWT token.
+    #   \return Dict containing some profile data.
+    def parseJWT(self, access_token: str) -> Optional["UserProfile"]:
+        try:
+            token_request = requests.get("{}/check-token".format(self._settings.OAUTH_SERVER_URL), headers = {
+                "Authorization": "Bearer {}".format(access_token)
+            })
+        except requests.exceptions.ConnectionError:
+            # Connection was suddenly dropped. Nothing we can do about that.
+            Logger.log("w", "Something failed while attempting to parse the JWT token")
+            return None
+        if token_request.status_code not in (200, 201):
+            Logger.log("w", "Could not retrieve token data from auth server: %s", token_request.text)
+            return None
+        user_data = token_request.json().get("data")
+        if not user_data or not isinstance(user_data, dict):
+            Logger.log("w", "Could not parse user data from token: %s", user_data)
+            return None
+        return UserProfile(
+            user_id = user_data["user_id"],
+            username = user_data["username"],
+            profile_image_url = user_data.get("profile_image_url", "")
+        )
+
+    @staticmethod
+    ##  Generate a 16-character verification code.
+    #   \param code_length: How long should the code be?
+    def generateVerificationCode(code_length: int = 16) -> str:
+        return "".join(random.choice("0123456789ABCDEF") for i in range(code_length))
+
+    @staticmethod
+    ##  Generates a base64 encoded sha512 encrypted version of a given string.
+    #   \param verification_code:
+    #   \return The encrypted code in base64 format.
+    def generateVerificationCodeChallenge(verification_code: str) -> str:
+        encoded = sha512(verification_code.encode()).digest()
+        return b64encode(encoded, altchars = b"_-").decode()

cura/OAuth2/AuthorizationRequestHandler.py

@@ -0,0 +1,103 @@
+# Copyright (c) 2019 Ultimaker B.V.
+# Cura is released under the terms of the LGPLv3 or higher.
+
+from http.server import BaseHTTPRequestHandler
+from typing import Optional, Callable, Tuple, Dict, Any, List, TYPE_CHECKING
+from urllib.parse import parse_qs, urlparse
+
+from cura.OAuth2.Models import AuthenticationResponse, ResponseData, HTTP_STATUS
+from UM.i18n import i18nCatalog
+
+if TYPE_CHECKING:
+    from cura.OAuth2.Models import ResponseStatus
+    from cura.OAuth2.AuthorizationHelpers import AuthorizationHelpers
+
+catalog = i18nCatalog("cura")
+
+##  This handler handles all HTTP requests on the local web server.
+#   It also requests the access token for the 2nd stage of the OAuth flow.
+class AuthorizationRequestHandler(BaseHTTPRequestHandler):
+    def __init__(self, request, client_address, server) -> None:
+        super().__init__(request, client_address, server)
+
+        # These values will be injected by the HTTPServer that this handler belongs to.
+        self.authorization_helpers = None  # type: Optional[AuthorizationHelpers]
+        self.authorization_callback = None  # type: Optional[Callable[[AuthenticationResponse], None]]
+        self.verification_code = None  # type: Optional[str]
+
+    def do_GET(self) -> None:
+        # Extract values from the query string.
+        parsed_url = urlparse(self.path)
+        query = parse_qs(parsed_url.query)
+
+        # Handle the possible requests
+        if parsed_url.path == "/callback":
+            server_response, token_response = self._handleCallback(query)
+        else:
+            server_response = self._handleNotFound()
+            token_response = None
+
+        # Send the data to the browser.
+        self._sendHeaders(server_response.status, server_response.content_type, server_response.redirect_uri)
+
+        if server_response.data_stream:
+            # If there is data in the response, we send it.
+            self._sendData(server_response.data_stream)
+
+        if token_response and self.authorization_callback is not None:
+            # Trigger the callback if we got a response.
+            # This will cause the server to shut down, so we do it at the very end of the request handling.
+            self.authorization_callback(token_response)
+
+    ##  Handler for the callback URL redirect.
+    #   \param query Dict containing the HTTP query parameters.
+    #   \return HTTP ResponseData containing a success page to show to the user.
+    def _handleCallback(self, query: Dict[Any, List]) -> Tuple[ResponseData, Optional[AuthenticationResponse]]:
+        code = self._queryGet(query, "code")
+        if code and self.authorization_helpers is not None and self.verification_code is not None:
+            # If the code was returned we get the access token.
+            token_response = self.authorization_helpers.getAccessTokenUsingAuthorizationCode(
+                code, self.verification_code)
+
+        elif self._queryGet(query, "error_code") == "user_denied":
+            # Otherwise we show an error message (probably the user clicked "Deny" in the auth dialog).
+            token_response = AuthenticationResponse(
+                success = False,
+                err_message = catalog.i18nc("@message", "Please give the required permissions when authorizing this application.")
+            )
+
+        else:
+            # We don't know what went wrong here, so instruct the user to check the logs.
+            token_response = AuthenticationResponse(
+                success = False,
+                error_message = catalog.i18nc("@message", "Something unexpected happened when trying to log in, please try again.")
+            )
+        if self.authorization_helpers is None:
+            return ResponseData(), token_response
+
+        return ResponseData(
+            status = HTTP_STATUS["REDIRECT"],
+            data_stream = b"Redirecting...",
+            redirect_uri = self.authorization_helpers.settings.AUTH_SUCCESS_REDIRECT if token_response.success else
+            self.authorization_helpers.settings.AUTH_FAILED_REDIRECT
+        ), token_response
+
+    ##  Handle all other non-existing server calls.
+    @staticmethod
+    def _handleNotFound() -> ResponseData:
+        return ResponseData(status = HTTP_STATUS["NOT_FOUND"], content_type = "text/html", data_stream = b"Not found.")
+
+    def _sendHeaders(self, status: "ResponseStatus", content_type: str, redirect_uri: str = None) -> None:
+        self.send_response(status.code, status.message)
+        self.send_header("Content-type", content_type)
+        if redirect_uri:
+            self.send_header("Location", redirect_uri)
+        self.end_headers()
+
+    def _sendData(self, data: bytes) -> None:
+        self.wfile.write(data)
+
+    ##  Convenience helper for getting values from a pre-parsed query string
+    @staticmethod
+    def _queryGet(query_data: Dict[Any, List], key: str, default: Optional[str] = None) -> Optional[str]:
+        return query_data.get(key, [default])[0]

cura/OAuth2/AuthorizationRequestServer.py

@@ -0,0 +1,27 @@
+# Copyright (c) 2019 Ultimaker B.V.
+# Cura is released under the terms of the LGPLv3 or higher.
+
+from http.server import HTTPServer
+from typing import Callable, Any, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from cura.OAuth2.Models import AuthenticationResponse
+    from cura.OAuth2.AuthorizationHelpers import AuthorizationHelpers
+
+
+##  The authorization request callback handler server.
+#   This subclass is needed to be able to pass some data to the request handler.
+#   This cannot be done on the request handler directly as the HTTPServer
+#   creates an instance of the handler after init.
+class AuthorizationRequestServer(HTTPServer):
+    ##  Set the authorization helpers instance on the request handler.
+    def setAuthorizationHelpers(self, authorization_helpers: "AuthorizationHelpers") -> None:
+        self.RequestHandlerClass.authorization_helpers = authorization_helpers  # type: ignore
+
+    ##  Set the authorization callback on the request handler.
+    def setAuthorizationCallback(self, authorization_callback: Callable[["AuthenticationResponse"], Any]) -> None:
+        self.RequestHandlerClass.authorization_callback = authorization_callback  # type: ignore
+
+    ##  Set the verification code on the request handler.
+    def setVerificationCode(self, verification_code: str) -> None:
+        self.RequestHandlerClass.verification_code = verification_code  # type: ignore

cura/OAuth2/AuthorizationService.py

@@ -0,0 +1,207 @@
+# Copyright (c) 2019 Ultimaker B.V.
+# Cura is released under the terms of the LGPLv3 or higher.
+
+import json
+import webbrowser
+from datetime import datetime, timedelta
+from typing import Optional, TYPE_CHECKING
+from urllib.parse import urlencode
+import requests.exceptions
+
+
+from UM.Logger import Logger
+from UM.Message import Message
+from UM.Signal import Signal
+
+from cura.OAuth2.LocalAuthorizationServer import LocalAuthorizationServer
+from cura.OAuth2.AuthorizationHelpers import AuthorizationHelpers, TOKEN_TIMESTAMP_FORMAT
+from cura.OAuth2.Models import AuthenticationResponse
+
+from UM.i18n import i18nCatalog
+i18n_catalog = i18nCatalog("cura")
+
+if TYPE_CHECKING:
+    from cura.OAuth2.Models import UserProfile, OAuth2Settings
+    from UM.Preferences import Preferences
+
+
+##  The authorization service is responsible for handling the login flow,
+#   storing user credentials and providing account information.
+class AuthorizationService:
+    # Emit signal when authentication is completed.
+    onAuthStateChanged = Signal()
+
+    # Emit signal when authentication failed.
+    onAuthenticationError = Signal()
+
+    def __init__(self, settings: "OAuth2Settings", preferences: Optional["Preferences"] = None) -> None:
+        self._settings = settings
+        self._auth_helpers = AuthorizationHelpers(settings)
+        self._auth_url = "{}/authorize".format(self._settings.OAUTH_SERVER_URL)
+        self._auth_data = None  # type: Optional[AuthenticationResponse]
+        self._user_profile = None  # type: Optional["UserProfile"]
+        self._preferences = preferences
+        self._server = LocalAuthorizationServer(self._auth_helpers, self._onAuthStateChanged, daemon=True)
+
+        self._unable_to_get_data_message = None  # type: Optional[Message]
+
+        self.onAuthStateChanged.connect(self._authChanged)
+
+    def _authChanged(self, logged_in):
+        if logged_in and self._unable_to_get_data_message is not None:
+            self._unable_to_get_data_message.hide()
+
+    def initialize(self, preferences: Optional["Preferences"] = None) -> None:
+        if preferences is not None:
+            self._preferences = preferences
+        if self._preferences:
+            self._preferences.addPreference(self._settings.AUTH_DATA_PREFERENCE_KEY, "{}")
+
+    ##  Get the user profile as obtained from the JWT (JSON Web Token).
+    #   If the JWT is not yet parsed, calling this will take care of that.
+    #   \return UserProfile if a user is logged in, None otherwise.
+    #   \sa _parseJWT
+    def getUserProfile(self) -> Optional["UserProfile"]:
+        if not self._user_profile:
+            # If no user profile was stored locally, we try to get it from JWT.
+            try:
+                self._user_profile = self._parseJWT()
+            except requests.exceptions.ConnectionError:
+                # Unable to get connection, can't login.
+                return None
+
+        if not self._user_profile and self._auth_data:
+            # If there is still no user profile from the JWT, we have to log in again.
+            Logger.log("w", "The user profile could not be loaded. The user must log in again!")
+            self.deleteAuthData()
+            return None
+
+        return self._user_profile
+
+    ##  Tries to parse the JWT (JSON Web Token) data, which it does if all the needed data is there.
+    #   \return UserProfile if it was able to parse, None otherwise.
+    def _parseJWT(self) -> Optional["UserProfile"]:
+        if not self._auth_data or self._auth_data.access_token is None:
+            # If no auth data exists, we should always log in again.
+            return None
+        user_data = self._auth_helpers.parseJWT(self._auth_data.access_token)
+        if user_data:
+            # If the profile was found, we return it immediately.
+            return user_data
+        # The JWT was expired or invalid and we should request a new one.
+        if self._auth_data.refresh_token is None:
+            return None
+        self._auth_data = self._auth_helpers.getAccessTokenUsingRefreshToken(self._auth_data.refresh_token)
+        if not self._auth_data or self._auth_data.access_token is None:
+            # The token could not be refreshed using the refresh token. We should login again.
+            return None
+
+        return self._auth_helpers.parseJWT(self._auth_data.access_token)
+
+    ##  Get the access token as provided by the repsonse data.
+    def getAccessToken(self) -> Optional[str]:
+        if self._auth_data is None:
+            Logger.log("d", "No auth data to retrieve the access_token from")
+            return None
+
+        # Check if the current access token is expired and refresh it if that is the case.
+        # We have a fallback on a date far in the past for currently stored auth data in cura.cfg.
+        received_at = datetime.strptime(self._auth_data.received_at, TOKEN_TIMESTAMP_FORMAT) \
+            if self._auth_data.received_at else datetime(2000, 1, 1)
+        expiry_date = received_at + timedelta(seconds = float(self._auth_data.expires_in or 0))
+        if datetime.now() > expiry_date:
+            self.refreshAccessToken()
+
+        return self._auth_data.access_token if self._auth_data else None
+
+    ##  Try to refresh the access token. This should be used when it has expired.
+    def refreshAccessToken(self) -> None:
+        if self._auth_data is None or self._auth_data.refresh_token is None:
+            Logger.log("w", "Unable to refresh access token, since there is no refresh token.")
+            return
+        self._storeAuthData(self._auth_helpers.getAccessTokenUsingRefreshToken(self._auth_data.refresh_token))
+        self.onAuthStateChanged.emit(logged_in = True)
+
+    ##  Delete the authentication data that we have stored locally (eg; logout)
+    def deleteAuthData(self) -> None:
+        if self._auth_data is not None:
+            self._storeAuthData()
+            self.onAuthStateChanged.emit(logged_in = False)
+
+    ##  Start the flow to become authenticated. This will start a new webbrowser tap, prompting the user to login.
+    def startAuthorizationFlow(self) -> None:
+        Logger.log("d", "Starting new OAuth2 flow...")
+
+        # Create the tokens needed for the code challenge (PKCE) extension for OAuth2.
+        # This is needed because the CuraDrivePlugin is a untrusted (open source) client.
+        # More details can be found at https://tools.ietf.org/html/rfc7636.
+        verification_code = self._auth_helpers.generateVerificationCode()
+        challenge_code = self._auth_helpers.generateVerificationCodeChallenge(verification_code)
+
+        # Create the query string needed for the OAuth2 flow.
+        query_string = urlencode({
+            "client_id": self._settings.CLIENT_ID,
+            "redirect_uri": self._settings.CALLBACK_URL,
+            "scope": self._settings.CLIENT_SCOPES,
+            "response_type": "code",
+            "state": "(.Y.)",
+            "code_challenge": challenge_code,
+            "code_challenge_method": "S512"
+        })
+
+        # Open the authorization page in a new browser window.
+        webbrowser.open_new("{}?{}".format(self._auth_url, query_string))
+
+        # Start a local web server to receive the callback URL on.
+        self._server.start(verification_code)
+
+    ##  Callback method for the authentication flow.
+    def _onAuthStateChanged(self, auth_response: AuthenticationResponse) -> None:
+        if auth_response.success:
+            self._storeAuthData(auth_response)
+            self.onAuthStateChanged.emit(logged_in = True)
+        else:
+            self.onAuthenticationError.emit(logged_in = False, error_message = auth_response.err_message)
+        self._server.stop()  # Stop the web server at all times.
+
+    ##  Load authentication data from preferences.
+    def loadAuthDataFromPreferences(self) -> None:
+        if self._preferences is None:
+            Logger.log("e", "Unable to load authentication data, since no preference has been set!")
+            return
+        try:
+            preferences_data = json.loads(self._preferences.getValue(self._settings.AUTH_DATA_PREFERENCE_KEY))
+            if preferences_data:
+                self._auth_data = AuthenticationResponse(**preferences_data)
+                # Also check if we can actually get the user profile information.
+                user_profile = self.getUserProfile()
+                if user_profile is not None:
+                    self.onAuthStateChanged.emit(logged_in = True)
+                else:
+                    if self._unable_to_get_data_message is not None:
+                        self._unable_to_get_data_message.hide()
+
+                    self._unable_to_get_data_message = Message(i18n_catalog.i18nc("@info", "Unable to reach the Ultimaker account server."), title = i18n_catalog.i18nc("@info:title", "Warning"))
+                    self._unable_to_get_data_message.addAction("retry", i18n_catalog.i18nc("@action:button", "Retry"), "[no_icon]", "[no_description]")
+                    self._unable_to_get_data_message.actionTriggered.connect(self._onMessageActionTriggered)
+                    self._unable_to_get_data_message.show()
+        except ValueError:
+            Logger.logException("w", "Could not load auth data from preferences")
+
+    ##  Store authentication data in preferences.
+    def _storeAuthData(self, auth_data: Optional[AuthenticationResponse] = None) -> None:
+        if self._preferences is None:
+            Logger.log("e", "Unable to save authentication data, since no preference has been set!")
+            return
+        
+        self._auth_data = auth_data
+        if auth_data:
+            self._user_profile = self.getUserProfile()
+            self._preferences.setValue(self._settings.AUTH_DATA_PREFERENCE_KEY, json.dumps(vars(auth_data)))
+        else:
+            self._user_profile = None
+            self._preferences.resetPreference(self._settings.AUTH_DATA_PREFERENCE_KEY)
+
+    def _onMessageActionTriggered(self, _, action):
+        if action == "retry":
+            self.loadAuthDataFromPreferences()

cura/OAuth2/LocalAuthorizationServer.py

@@ -0,0 +1,68 @@
+# Copyright (c) 2019 Ultimaker B.V.
+# Cura is released under the terms of the LGPLv3 or higher.
+
+import threading
+from typing import Optional, Callable, Any, TYPE_CHECKING
+
+from UM.Logger import Logger
+
+from cura.OAuth2.AuthorizationRequestServer import AuthorizationRequestServer
+from cura.OAuth2.AuthorizationRequestHandler import AuthorizationRequestHandler
+
+if TYPE_CHECKING:
+    from cura.OAuth2.Models import AuthenticationResponse
+    from cura.OAuth2.AuthorizationHelpers import AuthorizationHelpers
+
+
+class LocalAuthorizationServer:
+    ##  The local LocalAuthorizationServer takes care of the oauth2 callbacks.
+    #   Once the flow is completed, this server should be closed down again by
+    #   calling stop()
+    #   \param auth_helpers An instance of the authorization helpers class.
+    #   \param auth_state_changed_callback A callback function to be called when
+    #   the authorization state changes.
+    #   \param daemon Whether the server thread should be run in daemon mode.
+    #   Note: Daemon threads are abruptly stopped at shutdown. Their resources
+    #   (e.g. open files) may never be released.
+    def __init__(self, auth_helpers: "AuthorizationHelpers",
+                 auth_state_changed_callback: Callable[["AuthenticationResponse"], Any],
+                 daemon: bool) -> None:
+        self._web_server = None  # type: Optional[AuthorizationRequestServer]
+        self._web_server_thread = None  # type: Optional[threading.Thread]
+        self._web_server_port = auth_helpers.settings.CALLBACK_PORT
+        self._auth_helpers = auth_helpers
+        self._auth_state_changed_callback = auth_state_changed_callback
+        self._daemon = daemon
+
+    ##  Starts the local web server to handle the authorization callback.
+    #   \param verification_code The verification code part of the OAuth2 client identification.
+    def start(self, verification_code: str) -> None:
+        if self._web_server:
+            # If the server is already running (because of a previously aborted auth flow), we don't have to start it.
+            # We still inject the new verification code though.
+            self._web_server.setVerificationCode(verification_code)
+            return
+
+        if self._web_server_port is None:
+            raise Exception("Unable to start server without specifying the port.")
+
+        Logger.log("d", "Starting local web server to handle authorization callback on port %s", self._web_server_port)
+
+        # Create the server and inject the callback and code.
+        self._web_server = AuthorizationRequestServer(("0.0.0.0", self._web_server_port), AuthorizationRequestHandler)
+        self._web_server.setAuthorizationHelpers(self._auth_helpers)
+        self._web_server.setAuthorizationCallback(self._auth_state_changed_callback)
+        self._web_server.setVerificationCode(verification_code)
+
+        # Start the server on a new thread.
+        self._web_server_thread = threading.Thread(None, self._web_server.serve_forever, daemon = self._daemon)
+        self._web_server_thread.start()
+
+    ##  Stops the web server if it was running. It also does some cleanup.
+    def stop(self) -> None:
+        Logger.log("d", "Stopping local oauth2 web server...")
+
+        if self._web_server:
+            self._web_server.server_close()
+        self._web_server = None
+        self._web_server_thread = None

cura/OAuth2/Models.py

@@ -0,0 +1,61 @@
+# Copyright (c) 2019 Ultimaker B.V.
+# Cura is released under the terms of the LGPLv3 or higher.
+from typing import Optional
+
+
+class BaseModel:
+    def __init__(self, **kwargs):
+        self.__dict__.update(kwargs)
+
+
+##  OAuth OAuth2Settings data template.
+class OAuth2Settings(BaseModel):
+    CALLBACK_PORT = None  # type: Optional[int]
+    OAUTH_SERVER_URL = None  # type: Optional[str]
+    CLIENT_ID = None  # type: Optional[str]
+    CLIENT_SCOPES = None  # type: Optional[str]
+    CALLBACK_URL = None  # type: Optional[str]
+    AUTH_DATA_PREFERENCE_KEY = ""  # type: str
+    AUTH_SUCCESS_REDIRECT = "https://ultimaker.com"  # type: str
+    AUTH_FAILED_REDIRECT = "https://ultimaker.com"  # type: str
+
+
+##  User profile data template.
+class UserProfile(BaseModel):
+    user_id = None  # type: Optional[str]
+    username = None  # type: Optional[str]
+    profile_image_url = None  # type: Optional[str]
+
+
+##  Authentication data template.
+class AuthenticationResponse(BaseModel):
+    """Data comes from the token response with success flag and error message added."""
+    success = True  # type: bool
+    token_type = None  # type: Optional[str]
+    access_token = None  # type: Optional[str]
+    refresh_token = None  # type: Optional[str]
+    expires_in = None  # type: Optional[str]
+    scope = None  # type: Optional[str]
+    err_message = None  # type: Optional[str]
+    received_at = None  # type: Optional[str]
+
+
+##  Response status template.
+class ResponseStatus(BaseModel):
+    code = 200  # type: int
+    message = ""  # type: str
+
+
+##  Response data template.
+class ResponseData(BaseModel):
+    status = None  # type: ResponseStatus
+    data_stream = None  # type: Optional[bytes]
+    redirect_uri = None  # type: Optional[str]
+    content_type = "text/html"  # type: str
+
+##  Possible HTTP responses.
+HTTP_STATUS = {
+    "OK": ResponseStatus(code = 200, message = "OK"),
+    "NOT_FOUND": ResponseStatus(code = 404, message = "NOT FOUND"),
+    "REDIRECT": ResponseStatus(code = 302, message = "REDIRECT")
+}

cura/OAuth2/__init__.py

@@ -0,0 +1,2 @@
+# Copyright (c) 2019 Ultimaker B.V.
+# Cura is released under the terms of the LGPLv3 or higher.

cura/ObjectsModel.py

@@ -5,10 +5,12 @@ from PyQt5.QtCore import QTimer
 
 from UM.Application import Application
 from UM.Qt.ListModel import ListModel
+from UM.Scene.Camera import Camera
 from UM.Scene.Iterator.DepthFirstIterator import DepthFirstIterator
 from UM.Scene.SceneNode import SceneNode
 from UM.Scene.Selection import Selection
 from UM.i18n import i18nCatalog
+from collections import defaultdict
 
 catalog = i18nCatalog("cura")
 
@@ -18,19 +20,24 @@ class ObjectsModel(ListModel):
     def __init__(self):
         super().__init__()
 
-        Application.getInstance().getController().getScene().sceneChanged.connect(self._updateDelayed)
+        Application.getInstance().getController().getScene().sceneChanged.connect(self._updateSceneDelayed)
         Application.getInstance().getPreferences().preferenceChanged.connect(self._updateDelayed)
 
         self._update_timer = QTimer()
-        self._update_timer.setInterval(100)
+        self._update_timer.setInterval(200)
         self._update_timer.setSingleShot(True)
         self._update_timer.timeout.connect(self._update)
 
         self._build_plate_number = -1
 
     def setActiveBuildPlate(self, nr):
-        self._build_plate_number = nr
-        self._update()
+        if self._build_plate_number != nr:
+            self._build_plate_number = nr
+            self._update()
+
+    def _updateSceneDelayed(self, source):
+        if not isinstance(source, Camera):
+            self._update_timer.start()
 
     def _updateDelayed(self, *args):
         self._update_timer.start()
@@ -40,6 +47,8 @@ class ObjectsModel(ListModel):
         filter_current_build_plate = Application.getInstance().getPreferences().getValue("view/filter_current_build_plate")
         active_build_plate_number = self._build_plate_number
         group_nr = 1
+        name_count_dict = defaultdict(int)
+
         for node in DepthFirstIterator(Application.getInstance().getController().getScene().getRoot()):
             if not isinstance(node, SceneNode):
                 continue
@@ -55,6 +64,7 @@ class ObjectsModel(ListModel):
 
             if not node.callDecoration("isGroup"):
                 name = node.getName()
+                
             else:
                 name = catalog.i18nc("@label", "Group #{group_nr}").format(group_nr = str(group_nr))
                 group_nr += 1
@@ -63,6 +73,14 @@ class ObjectsModel(ListModel):
                 is_outside_build_area = node.isOutsideBuildArea()
             else:
                 is_outside_build_area = False
+                
+            #check if we already have an instance of the object based on name
+            name_count_dict[name] += 1
+            name_count = name_count_dict[name]
+
+            if name_count > 1:
+                name = "{0}({1})".format(name, name_count-1)
+                node.setName(name)
 
             nodes.append({
                 "name": name,
@@ -71,6 +89,7 @@ class ObjectsModel(ListModel):
                 "buildPlateNumber": node_build_plate_number,
                 "node": node
             })
+       
         nodes = sorted(nodes, key=lambda n: n["name"])
         self.setItems(nodes)
 

cura/PlatformPhysics.py

@@ -17,7 +17,6 @@ from cura.Scene import ZOffsetDecorator
 
 import random  # used for list shuffling
 
-
 class PlatformPhysics:
     def __init__(self, controller, volume):
         super().__init__()
@@ -40,8 +39,9 @@ class PlatformPhysics:
         Application.getInstance().getPreferences().addPreference("physics/automatic_drop_down", True)
 
     def _onSceneChanged(self, source):
-        if not source.getMeshData():
+        if not source.callDecoration("isSliceable"):
             return
+
         self._change_timer.start()
 
     def _onChangeTimerFinished(self):

cura/PrintInformation.py

@@ -6,73 +6,58 @@ import math
 import os
 import unicodedata
 import re  # To create abbreviations for printer names.
-from typing import Dict
+from typing import Dict, List, Optional
 
 from PyQt5.QtCore import QObject, pyqtSignal, pyqtProperty, pyqtSlot
 
-from UM.i18n import i18nCatalog
 from UM.Logger import Logger
 from UM.Qt.Duration import Duration
 from UM.Scene.SceneNode import SceneNode
 from UM.i18n import i18nCatalog
-from UM.MimeTypeDatabase import MimeTypeDatabase
+from UM.MimeTypeDatabase import MimeTypeDatabase, MimeTypeNotFoundError
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from cura.CuraApplication import CuraApplication
 
 catalog = i18nCatalog("cura")
 
 
-##  A class for processing and calculating minimum, current and maximum print time as well as managing the job name
-#
-#   This class contains all the logic relating to calculation and slicing for the
-#   time/quality slider concept. It is a rather tricky combination of event handling
-#   and state management. The logic behind this is as follows:
-#
-#   - A scene change or setting change event happens.
-#        We track what the source was of the change, either a scene change, a setting change, an active machine change or something else.
-#   - This triggers a new slice with the current settings - this is the "current settings pass".
-#   - When the slice is done, we update the current print time and material amount.
-#   - If the source of the slice was not a Setting change, we start the second slice pass, the "low quality settings pass". Otherwise we stop here.
-#   - When that is done, we update the minimum print time and start the final slice pass, the "Extra Fine settings pass".
-#   - When the Extra Fine pass is done, we update the maximum print time.
+##  A class for processing and the print times per build plate as well as managing the job name
 #
 #   This class also mangles the current machine name and the filename of the first loaded mesh into a job name.
 #   This job name is requested by the JobSpecs qml file.
 class PrintInformation(QObject):
-    class SlicePass:
-        CurrentSettings = 1
-        LowQualitySettings = 2
-        HighQualitySettings = 3
 
-    class SliceReason:
-        SceneChanged = 1
-        SettingChanged = 2
-        ActiveMachineChanged = 3
-        Other = 4
+    UNTITLED_JOB_NAME = "Untitled"
 
-    def __init__(self, application, parent = None):
+    def __init__(self, application: "CuraApplication", parent = None) -> None:
         super().__init__(parent)
         self._application = application
 
         self.initializeCuraMessagePrintTimeProperties()
 
-        self._material_lengths = {}  # indexed by build plate number
-        self._material_weights = {}
-        self._material_costs = {}
-        self._material_names = {}
+        # Indexed by build plate number
+        self._material_lengths = {}  # type: Dict[int, List[float]]
+        self._material_weights = {}  # type: Dict[int, List[float]]
+        self._material_costs = {}   # type: Dict[int, List[float]]
+        self._material_names = {}  # type: Dict[int, List[str]]
 
         self._pre_sliced = False
 
         self._backend = self._application.getBackend()
         if self._backend:
             self._backend.printDurationMessage.connect(self._onPrintDurationMessage)
+
         self._application.getController().getScene().sceneChanged.connect(self._onSceneChanged)
 
         self._is_user_specified_job_name = False
         self._base_name = ""
         self._abbr_machine = ""
         self._job_name = ""
-        self._project_name = ""
         self._active_build_plate = 0
-        self._initVariablesWithBuildPlate(self._active_build_plate)
+        self._initVariablesByBuildPlate(self._active_build_plate)
 
         self._multi_build_plate_model = self._application.getMultiBuildPlateModel()
 
@@ -80,19 +65,15 @@ class PrintInformation(QObject):
         self._application.globalContainerStackChanged.connect(self.setToZeroPrintInformation)
         self._application.fileLoaded.connect(self.setBaseName)
         self._application.workspaceLoaded.connect(self.setProjectName)
-        self._multi_build_plate_model.activeBuildPlateChanged.connect(self._onActiveBuildPlateChanged)
-
+        self._application.getMachineManager().rootMaterialChanged.connect(self._onActiveMaterialsChanged)
         self._application.getInstance().getPreferences().preferenceChanged.connect(self._onPreferencesChanged)
 
-        self._application.getMachineManager().rootMaterialChanged.connect(self._onActiveMaterialsChanged)
+        self._multi_build_plate_model.activeBuildPlateChanged.connect(self._onActiveBuildPlateChanged)
+        self._material_amounts = []  # type: List[float]
         self._onActiveMaterialsChanged()
 
-        self._material_amounts = []
-
-    # Crate cura message translations and using translation keys initialize empty time Duration object for total time
-    # and time for each feature
-    def initializeCuraMessagePrintTimeProperties(self):
-        self._current_print_time = {}  # Duration(None, self)
+    def initializeCuraMessagePrintTimeProperties(self) -> None:
+        self._current_print_time = {}  # type: Dict[int, Duration]
 
         self._print_time_message_translations = {
             "inset_0": catalog.i18nc("@tooltip", "Outer Wall"),
@@ -108,17 +89,17 @@ class PrintInformation(QObject):
             "none": catalog.i18nc("@tooltip", "Other")
         }
 
-        self._print_time_message_values = {}
+        self._print_times_per_feature = {}  # type: Dict[int, Dict[str, Duration]]
 
-    def _initPrintTimeMessageValues(self, build_plate_number):
+    def _initPrintTimesPerFeature(self, build_plate_number: int) -> None:
         # Full fill message values using keys from _print_time_message_translations
-        self._print_time_message_values[build_plate_number] = {}
+        self._print_times_per_feature[build_plate_number] = {}
         for key in self._print_time_message_translations.keys():
-            self._print_time_message_values[build_plate_number][key] = Duration(None, self)
+            self._print_times_per_feature[build_plate_number][key] = Duration(None, self)
 
-    def _initVariablesWithBuildPlate(self, build_plate_number):
-        if build_plate_number not in self._print_time_message_values:
-            self._initPrintTimeMessageValues(build_plate_number)
+    def _initVariablesByBuildPlate(self, build_plate_number: int) -> None:
+        if build_plate_number not in self._print_times_per_feature:
+            self._initPrintTimesPerFeature(build_plate_number)
         if self._active_build_plate not in self._material_lengths:
             self._material_lengths[self._active_build_plate] = []
         if self._active_build_plate not in self._material_weights:
@@ -128,23 +109,24 @@ class PrintInformation(QObject):
         if self._active_build_plate not in self._material_names:
             self._material_names[self._active_build_plate] = []
         if self._active_build_plate not in self._current_print_time:
-            self._current_print_time[self._active_build_plate] = Duration(None, self)
+            self._current_print_time[self._active_build_plate] = Duration(parent = self)
 
     currentPrintTimeChanged = pyqtSignal()
 
     preSlicedChanged = pyqtSignal()
 
     @pyqtProperty(bool, notify=preSlicedChanged)
-    def preSliced(self):
+    def preSliced(self) -> bool:
         return self._pre_sliced
 
-    def setPreSliced(self, pre_sliced):
-        self._pre_sliced = pre_sliced
-        self._updateJobName()
-        self.preSlicedChanged.emit()
+    def setPreSliced(self, pre_sliced: bool) -> None:
+        if self._pre_sliced != pre_sliced:
+            self._pre_sliced = pre_sliced
+            self._updateJobName()
+            self.preSlicedChanged.emit()
 
     @pyqtProperty(Duration, notify = currentPrintTimeChanged)
-    def currentPrintTime(self):
+    def currentPrintTime(self) -> Duration:
         return self._current_print_time[self._active_build_plate]
 
     materialLengthsChanged = pyqtSignal()
@@ -171,36 +153,41 @@ class PrintInformation(QObject):
     def materialNames(self):
         return self._material_names[self._active_build_plate]
 
-    def printTimes(self):
-        return self._print_time_message_values[self._active_build_plate]
+    #   Get all print times (by feature) of the active buildplate.
+    def printTimes(self) -> Dict[str, Duration]:
+        return self._print_times_per_feature[self._active_build_plate]
 
-    def _onPrintDurationMessage(self, build_plate_number, print_time: Dict[str, int], material_amounts: list):
-        self._updateTotalPrintTimePerFeature(build_plate_number, print_time)
+    def _onPrintDurationMessage(self, build_plate_number: int, print_times_per_feature: Dict[str, int], material_amounts: List[float]) -> None:
+        self._updateTotalPrintTimePerFeature(build_plate_number, print_times_per_feature)
         self.currentPrintTimeChanged.emit()
 
         self._material_amounts = material_amounts
         self._calculateInformation(build_plate_number)
 
-    def _updateTotalPrintTimePerFeature(self, build_plate_number, print_time: Dict[str, int]):
+    def _updateTotalPrintTimePerFeature(self, build_plate_number: int, print_times_per_feature: Dict[str, int]) -> None:
         total_estimated_time = 0
 
-        if build_plate_number not in self._print_time_message_values:
-            self._initPrintTimeMessageValues(build_plate_number)
+        if build_plate_number not in self._print_times_per_feature:
+            self._initPrintTimesPerFeature(build_plate_number)
+
+        for feature, time in print_times_per_feature.items():
+            if feature not in self._print_times_per_feature[build_plate_number]:
+                self._print_times_per_feature[build_plate_number][feature] = Duration(parent=self)
+            duration = self._print_times_per_feature[build_plate_number][feature]
 
-        for feature, time in print_time.items():
             if time != time:  # Check for NaN. Engine can sometimes give us weird values.
-                self._print_time_message_values[build_plate_number].get(feature).setDuration(0)
+                duration.setDuration(0)
                 Logger.log("w", "Received NaN for print duration message")
                 continue
 
             total_estimated_time += time
-            self._print_time_message_values[build_plate_number].get(feature).setDuration(time)
+            duration.setDuration(time)
 
         if build_plate_number not in self._current_print_time:
             self._current_print_time[build_plate_number] = Duration(None, self)
         self._current_print_time[build_plate_number].setDuration(total_estimated_time)
 
-    def _calculateInformation(self, build_plate_number):
+    def _calculateInformation(self, build_plate_number: int) -> None:
         global_stack = self._application.getGlobalContainerStack()
         if global_stack is None:
             return
@@ -213,39 +200,46 @@ class PrintInformation(QObject):
         material_preference_values = json.loads(self._application.getInstance().getPreferences().getValue("cura/material_settings"))
 
         extruder_stacks = global_stack.extruders
-        for position, extruder_stack in extruder_stacks.items():
+
+        for position in extruder_stacks:
+            extruder_stack = extruder_stacks[position]
             index = int(position)
             if index >= len(self._material_amounts):
                 continue
             amount = self._material_amounts[index]
-            ## Find the right extruder stack. As the list isn't sorted because it's a annoying generator, we do some
-            #  list comprehension filtering to solve this for us.
+            # Find the right extruder stack. As the list isn't sorted because it's a annoying generator, we do some
+            # list comprehension filtering to solve this for us.
             density = extruder_stack.getMetaDataEntry("properties", {}).get("density", 0)
-            material = extruder_stack.findContainer({"type": "material"})
+            material = extruder_stack.material
             radius = extruder_stack.getProperty("material_diameter", "value") / 2
 
             weight = float(amount) * float(density) / 1000
-            cost = 0
-            material_name = catalog.i18nc("@label unknown material", "Unknown")
-            if material:
-                material_guid = material.getMetaDataEntry("GUID")
-                material_name = material.getName()
-                if material_guid in material_preference_values:
-                    material_values = material_preference_values[material_guid]
+            cost = 0.
 
-                    weight_per_spool = float(material_values["spool_weight"] if material_values and "spool_weight" in material_values else 0)
-                    cost_per_spool = float(material_values["spool_cost"] if material_values and "spool_cost" in material_values else 0)
+            material_guid = material.getMetaDataEntry("GUID")
+            material_name = material.getName()
 
-                    if weight_per_spool != 0:
-                        cost = cost_per_spool * weight / weight_per_spool
-                    else:
-                        cost = 0
+            if material_guid in material_preference_values:
+                material_values = material_preference_values[material_guid]
+
+                if material_values and "spool_weight" in material_values:
+                    weight_per_spool = float(material_values["spool_weight"])
+                else:
+                    weight_per_spool = float(extruder_stack.getMetaDataEntry("properties", {}).get("weight", 0))
+
+                cost_per_spool = float(material_values["spool_cost"] if material_values and "spool_cost" in material_values else 0)
+
+                if weight_per_spool != 0:
+                    cost = cost_per_spool * weight / weight_per_spool
+                else:
+                    cost = 0
 
             # Material amount is sent as an amount of mm^3, so calculate length from that
             if radius != 0:
                 length = round((amount / (math.pi * radius ** 2)) / 1000, 2)
             else:
                 length = 0
+
             self._material_weights[build_plate_number].append(weight)
             self._material_lengths[build_plate_number].append(length)
             self._material_costs[build_plate_number].append(cost)
@@ -256,20 +250,20 @@ class PrintInformation(QObject):
         self.materialCostsChanged.emit()
         self.materialNamesChanged.emit()
 
-    def _onPreferencesChanged(self, preference):
+    def _onPreferencesChanged(self, preference: str) -> None:
         if preference != "cura/material_settings":
             return
 
         for build_plate_number in range(self._multi_build_plate_model.maxBuildPlate + 1):
             self._calculateInformation(build_plate_number)
 
-    def _onActiveBuildPlateChanged(self):
+    def _onActiveBuildPlateChanged(self) -> None:
         new_active_build_plate = self._multi_build_plate_model.activeBuildPlate
         if new_active_build_plate != self._active_build_plate:
             self._active_build_plate = new_active_build_plate
             self._updateJobName()
 
-            self._initVariablesWithBuildPlate(self._active_build_plate)
+            self._initVariablesByBuildPlate(self._active_build_plate)
 
             self.materialLengthsChanged.emit()
             self.materialWeightsChanged.emit()
@@ -277,14 +271,14 @@ class PrintInformation(QObject):
             self.materialNamesChanged.emit()
             self.currentPrintTimeChanged.emit()
 
-    def _onActiveMaterialsChanged(self, *args, **kwargs):
+    def _onActiveMaterialsChanged(self, *args, **kwargs) -> None:
         for build_plate_number in range(self._multi_build_plate_model.maxBuildPlate + 1):
             self._calculateInformation(build_plate_number)
 
     # Manual override of job name should also set the base name so that when the printer prefix is updated, it the
     # prefix can be added to the manually added name, not the old base name
     @pyqtSlot(str, bool)
-    def setJobName(self, name, is_user_specified_job_name = False):
+    def setJobName(self, name: str, is_user_specified_job_name = False) -> None:
         self._is_user_specified_job_name = is_user_specified_job_name
         self._job_name = name
         self._base_name = name.replace(self._abbr_machine + "_", "")
@@ -298,15 +292,15 @@ class PrintInformation(QObject):
     def jobName(self):
         return self._job_name
 
-    def _updateJobName(self):
+    def _updateJobName(self) -> None:
         if self._base_name == "":
-            self._job_name = "unnamed"
+            self._job_name = self.UNTITLED_JOB_NAME
             self._is_user_specified_job_name = False
             self.jobNameChanged.emit()
             return
 
         base_name = self._stripAccents(self._base_name)
-        self._setAbbreviatedMachineName()
+        self._defineAbbreviatedMachineName()
 
         # Only update the job name when it's not user-specified.
         if not self._is_user_specified_job_name:
@@ -333,12 +327,12 @@ class PrintInformation(QObject):
         self.jobNameChanged.emit()
 
     @pyqtSlot(str)
-    def setProjectName(self, name):
+    def setProjectName(self, name: str) -> None:
         self.setBaseName(name, is_project_file = True)
 
     baseNameChanged = pyqtSignal()
 
-    def setBaseName(self, base_name: str, is_project_file: bool = False):
+    def setBaseName(self, base_name: str, is_project_file: bool = False) -> None:
         self._is_user_specified_job_name = False
 
         # Ensure that we don't use entire path but only filename
@@ -365,7 +359,7 @@ class PrintInformation(QObject):
             try:
                 mime_type = MimeTypeDatabase.getMimeTypeForFile(name)
                 data = mime_type.stripExtension(name)
-            except:
+            except MimeTypeNotFoundError:
                 Logger.log("w", "Unsupported Mime Type Database file extension %s", name)
 
             if data is not None and check_name is not None:
@@ -373,6 +367,16 @@ class PrintInformation(QObject):
             else:
                 self._base_name = ""
 
+            # Strip the old "curaproject" extension from the name
+            OLD_CURA_PROJECT_EXT = ".curaproject"
+            if self._base_name.lower().endswith(OLD_CURA_PROJECT_EXT):
+                self._base_name = self._base_name[:len(self._base_name) - len(OLD_CURA_PROJECT_EXT)]
+
+            # CURA-5896 Try to strip extra extensions with an infinite amount of ".curaproject.3mf".
+            OLD_CURA_PROJECT_3MF_EXT = ".curaproject.3mf"
+            while self._base_name.lower().endswith(OLD_CURA_PROJECT_3MF_EXT):
+                self._base_name = self._base_name[:len(self._base_name) - len(OLD_CURA_PROJECT_3MF_EXT)]
+
             self._updateJobName()
 
     @pyqtProperty(str, fset = setBaseName, notify = baseNameChanged)
@@ -382,39 +386,25 @@ class PrintInformation(QObject):
     ##  Created an acronym-like abbreviated machine name from the currently
     #   active machine name.
     #   Called each time the global stack is switched.
-    def _setAbbreviatedMachineName(self):
+    def _defineAbbreviatedMachineName(self) -> None:
         global_container_stack = self._application.getGlobalContainerStack()
         if not global_container_stack:
             self._abbr_machine = ""
             return
         active_machine_type_name = global_container_stack.definition.getName()
 
-        abbr_machine = ""
-        for word in re.findall(r"[\w']+", active_machine_type_name):
-            if word.lower() == "ultimaker":
-                abbr_machine += "UM"
-            elif word.isdigit():
-                abbr_machine += word
-            else:
-                stripped_word = self._stripAccents(word.upper())
-                # - use only the first character if the word is too long (> 3 characters)
-                # - use the whole word if it's not too long (<= 3 characters)
-                if len(stripped_word) > 3:
-                    stripped_word = stripped_word[0]
-                abbr_machine += stripped_word
-
-        self._abbr_machine = abbr_machine
+        self._abbr_machine = self._application.getMachineManager().getAbbreviatedMachineName(active_machine_type_name)
 
     ##  Utility method that strips accents from characters (eg: â -> a)
-    def _stripAccents(self, str):
-        return ''.join(char for char in unicodedata.normalize('NFD', str) if unicodedata.category(char) != 'Mn')
+    def _stripAccents(self, to_strip: str) -> str:
+        return ''.join(char for char in unicodedata.normalize('NFD', to_strip) if unicodedata.category(char) != 'Mn')
 
     @pyqtSlot(result = "QVariantMap")
-    def getFeaturePrintTimes(self):
+    def getFeaturePrintTimes(self) -> Dict[str, Duration]:
         result = {}
-        if self._active_build_plate not in self._print_time_message_values:
-            self._initPrintTimeMessageValues(self._active_build_plate)
-        for feature, time in self._print_time_message_values[self._active_build_plate].items():
+        if self._active_build_plate not in self._print_times_per_feature:
+            self._initPrintTimesPerFeature(self._active_build_plate)
+        for feature, time in self._print_times_per_feature[self._active_build_plate].items():
             if feature in self._print_time_message_translations:
                 result[self._print_time_message_translations[feature]] = time
             else:
@@ -422,22 +412,22 @@ class PrintInformation(QObject):
         return result
 
     # Simulate message with zero time duration
-    def setToZeroPrintInformation(self, build_plate = None):
+    def setToZeroPrintInformation(self, build_plate: Optional[int] = None) -> None:
         if build_plate is None:
             build_plate = self._active_build_plate
 
         # Construct the 0-time message
         temp_message = {}
-        if build_plate not in self._print_time_message_values:
-            self._print_time_message_values[build_plate] = {}
-        for key in self._print_time_message_values[build_plate].keys():
+        if build_plate not in self._print_times_per_feature:
+            self._print_times_per_feature[build_plate] = {}
+        for key in self._print_times_per_feature[build_plate].keys():
             temp_message[key] = 0
-        temp_material_amounts = [0]
+        temp_material_amounts = [0.]
 
         self._onPrintDurationMessage(build_plate, temp_message, temp_material_amounts)
 
     ##  Listen to scene changes to check if we need to reset the print information
-    def _onSceneChanged(self, scene_node):
+    def _onSceneChanged(self, scene_node: SceneNode) -> None:
         # Ignore any changes that are not related to sliceable objects
         if not isinstance(scene_node, SceneNode)\
                 or not scene_node.callDecoration("isSliceable")\

cura/PrintJobPreviewImageProvider.py

@@ -0,0 +1,27 @@
+from PyQt5.QtGui import QImage
+from PyQt5.QtQuick import QQuickImageProvider
+from PyQt5.QtCore import QSize
+
+from UM.Application import Application
+
+
+class PrintJobPreviewImageProvider(QQuickImageProvider):
+    def __init__(self):
+        super().__init__(QQuickImageProvider.Image)
+
+    ##  Request a new image.
+    def requestImage(self, id: str, size: QSize) -> QImage:
+        # The id will have an uuid and an increment separated by a slash. As we don't care about the value of the
+        # increment, we need to strip that first.
+        uuid = id[id.find("/") + 1:]
+        for output_device in Application.getInstance().getOutputDeviceManager().getOutputDevices():
+            if not hasattr(output_device, "printJobs"):
+                continue
+
+            for print_job in output_device.printJobs:
+                if print_job.key == uuid:
+                    if print_job.getPreviewImage():
+                        return print_job.getPreviewImage(), QSize(15, 15)
+                    else:
+                        return QImage(), QSize(15, 15)
+        return QImage(), QSize(15,15)

cura/PrinterOutput/ConfigurationModel.py

@@ -13,42 +13,50 @@ class ConfigurationModel(QObject):
 
     configurationChanged = pyqtSignal()
 
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__()
-        self._printer_type = None
+        self._printer_type = ""
         self._extruder_configurations = []     # type: List[ExtruderConfigurationModel]
-        self._buildplate_configuration = None
+        self._buildplate_configuration = ""
 
     def setPrinterType(self, printer_type):
         self._printer_type = printer_type
 
     @pyqtProperty(str, fset = setPrinterType, notify = configurationChanged)
-    def printerType(self):
+    def printerType(self) -> str:
         return self._printer_type
 
-    def setExtruderConfigurations(self, extruder_configurations):
-        self._extruder_configurations = extruder_configurations
+    def setExtruderConfigurations(self, extruder_configurations: List["ExtruderConfigurationModel"]):
+        if self._extruder_configurations != extruder_configurations:
+            self._extruder_configurations = extruder_configurations
+
+            for extruder_configuration in self._extruder_configurations:
+                extruder_configuration.extruderConfigurationChanged.connect(self.configurationChanged)
+
+            self.configurationChanged.emit()
 
     @pyqtProperty("QVariantList", fset = setExtruderConfigurations, notify = configurationChanged)
     def extruderConfigurations(self):
         return self._extruder_configurations
 
-    def setBuildplateConfiguration(self, buildplate_configuration):
-        self._buildplate_configuration = buildplate_configuration
+    def setBuildplateConfiguration(self, buildplate_configuration: str) -> None:
+        if self._buildplate_configuration !=  buildplate_configuration:
+            self._buildplate_configuration = buildplate_configuration
+            self.configurationChanged.emit()
 
     @pyqtProperty(str, fset = setBuildplateConfiguration, notify = configurationChanged)
-    def buildplateConfiguration(self):
+    def buildplateConfiguration(self) -> str:
         return self._buildplate_configuration
 
     ##  This method is intended to indicate whether the configuration is valid or not.
     #   The method checks if the mandatory fields are or not set
-    def isValid(self):
+    def isValid(self) -> bool:
         if not self._extruder_configurations:
             return False
         for configuration in self._extruder_configurations:
             if configuration is None:
                 return False
-        return self._printer_type is not None
+        return self._printer_type != ""
 
     def __str__(self):
         message_chunks = []

cura/PrinterOutput/ExtruderConfigurationModel.py

@@ -1,56 +1,67 @@
 # Copyright (c) 2018 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
+from typing import Optional
 
 from PyQt5.QtCore import pyqtProperty, QObject, pyqtSignal
 
+from cura.PrinterOutput.MaterialOutputModel import MaterialOutputModel
+
 
 class ExtruderConfigurationModel(QObject):
 
     extruderConfigurationChanged = pyqtSignal()
 
-    def __init__(self):
+    def __init__(self, position: int = -1) -> None:
         super().__init__()
-        self._position = -1
-        self._material = None
-        self._hotend_id = None
+        self._position = position  # type: int
+        self._material = None  # type: Optional[MaterialOutputModel]
+        self._hotend_id = None  # type: Optional[str]
 
-    def setPosition(self, position):
+    def setPosition(self, position: int) -> None:
         self._position = position
 
     @pyqtProperty(int, fset = setPosition, notify = extruderConfigurationChanged)
-    def position(self):
+    def position(self) -> int:
         return self._position
 
-    def setMaterial(self, material):
-        self._material = material
+    def setMaterial(self, material: Optional[MaterialOutputModel]) -> None:
+        if self._hotend_id != material:
+            self._material = material
+            self.extruderConfigurationChanged.emit()
 
     @pyqtProperty(QObject, fset = setMaterial, notify = extruderConfigurationChanged)
-    def material(self):
+    def activeMaterial(self) -> Optional[MaterialOutputModel]:
         return self._material
 
-    def setHotendID(self, hotend_id):
-        self._hotend_id = hotend_id
+    @pyqtProperty(QObject, fset=setMaterial, notify=extruderConfigurationChanged)
+    def material(self) -> Optional[MaterialOutputModel]:
+        return self._material
+
+    def setHotendID(self, hotend_id: Optional[str]) -> None:
+        if self._hotend_id != hotend_id:
+            self._hotend_id = hotend_id
+            self.extruderConfigurationChanged.emit()
 
     @pyqtProperty(str, fset = setHotendID, notify = extruderConfigurationChanged)
-    def hotendID(self):
+    def hotendID(self) -> Optional[str]:
         return self._hotend_id
 
     ##  This method is intended to indicate whether the configuration is valid or not.
     #   The method checks if the mandatory fields are or not set
     #   At this moment is always valid since we allow to have empty material and variants.
-    def isValid(self):
+    def isValid(self) -> bool:
         return True
 
-    def __str__(self):
+    def __str__(self) -> str:
         message_chunks = []
         message_chunks.append("Position: " + str(self._position))
         message_chunks.append("-")
-        message_chunks.append("Material: " + self.material.type if self.material else "empty")
+        message_chunks.append("Material: " + self.activeMaterial.type if self.activeMaterial else "empty")
         message_chunks.append("-")
         message_chunks.append("HotendID: " + self.hotendID if self.hotendID else "empty")
         return " ".join(message_chunks)
 
-    def __eq__(self, other):
+    def __eq__(self, other) -> bool:
         return hash(self) == hash(other)
 
     #   Calculating a hash function using the position of the extruder, the material GUID and the hotend id to check if is

cura/PrinterOutput/ExtruderOutputModel.py

@@ -12,64 +12,61 @@ if TYPE_CHECKING:
 
 
 class ExtruderOutputModel(QObject):
-    hotendIDChanged = pyqtSignal()
     targetHotendTemperatureChanged = pyqtSignal()
     hotendTemperatureChanged = pyqtSignal()
-    activeMaterialChanged = pyqtSignal()
+
     extruderConfigurationChanged = pyqtSignal()
     isPreheatingChanged = pyqtSignal()
 
-    def __init__(self, printer: "PrinterOutputModel", position, parent=None) -> None:
+    def __init__(self, printer: "PrinterOutputModel", position: int, parent=None) -> None:
         super().__init__(parent)
-        self._printer = printer
+        self._printer = printer  # type: PrinterOutputModel
         self._position = position
-        self._target_hotend_temperature = 0 # type: float
-        self._hotend_temperature = 0 # type: float
-        self._hotend_id = ""
-        self._active_material = None  # type: Optional[MaterialOutputModel]
-        self._extruder_configuration = ExtruderConfigurationModel()
-        self._extruder_configuration.position = self._position
+        self._target_hotend_temperature = 0.0  # type: float
+        self._hotend_temperature = 0.0  # type: float
 
         self._is_preheating = False
 
-    def getPrinter(self):
+        # The extruder output model wraps the configuration model. This way we can use the same config model for jobs
+        # and extruders alike.
+        self._extruder_configuration = ExtruderConfigurationModel()
+        self._extruder_configuration.position = self._position
+        self._extruder_configuration.extruderConfigurationChanged.connect(self.extruderConfigurationChanged)
+
+    def getPrinter(self) -> "PrinterOutputModel":
         return self._printer
 
-    def getPosition(self):
+    def getPosition(self) -> int:
         return self._position
 
     # Does the printer support pre-heating the bed at all
     @pyqtProperty(bool, constant=True)
-    def canPreHeatHotends(self):
+    def canPreHeatHotends(self) -> bool:
         if self._printer:
             return self._printer.canPreHeatHotends
         return False
 
-    @pyqtProperty(QObject, notify = activeMaterialChanged)
+    @pyqtProperty(QObject, notify = extruderConfigurationChanged)
     def activeMaterial(self) -> Optional["MaterialOutputModel"]:
-        return self._active_material
+        return self._extruder_configuration.activeMaterial
 
-    def updateActiveMaterial(self, material: Optional["MaterialOutputModel"]):
-        if self._active_material != material:
-            self._active_material = material
-            self._extruder_configuration.material = self._active_material
-            self.activeMaterialChanged.emit()
-            self.extruderConfigurationChanged.emit()
+    def updateActiveMaterial(self, material: Optional["MaterialOutputModel"]) -> None:
+        self._extruder_configuration.setMaterial(material)
 
     ##  Update the hotend temperature. This only changes it locally.
-    def updateHotendTemperature(self, temperature: float):
+    def updateHotendTemperature(self, temperature: float) -> None:
         if self._hotend_temperature != temperature:
             self._hotend_temperature = temperature
             self.hotendTemperatureChanged.emit()
 
-    def updateTargetHotendTemperature(self, temperature: float):
+    def updateTargetHotendTemperature(self, temperature: float) -> None:
         if self._target_hotend_temperature != temperature:
             self._target_hotend_temperature = temperature
             self.targetHotendTemperatureChanged.emit()
 
     ##  Set the target hotend temperature. This ensures that it's actually sent to the remote.
     @pyqtSlot(float)
-    def setTargetHotendTemperature(self, temperature: float):
+    def setTargetHotendTemperature(self, temperature: float) -> None:
         self._printer.getController().setTargetHotendTemperature(self._printer, self, temperature)
         self.updateTargetHotendTemperature(temperature)
 
@@ -81,30 +78,26 @@ class ExtruderOutputModel(QObject):
     def hotendTemperature(self) -> float:
         return self._hotend_temperature
 
-    @pyqtProperty(str, notify = hotendIDChanged)
+    @pyqtProperty(str, notify = extruderConfigurationChanged)
     def hotendID(self) -> str:
-        return self._hotend_id
+        return self._extruder_configuration.hotendID
 
-    def updateHotendID(self, id: str):
-        if self._hotend_id != id:
-            self._hotend_id = id
-            self._extruder_configuration.hotendID = self._hotend_id
-            self.hotendIDChanged.emit()
-            self.extruderConfigurationChanged.emit()
+    def updateHotendID(self, hotend_id: str) -> None:
+        self._extruder_configuration.setHotendID(hotend_id)
 
     @pyqtProperty(QObject, notify = extruderConfigurationChanged)
-    def extruderConfiguration(self):
+    def extruderConfiguration(self) -> Optional[ExtruderConfigurationModel]:
         if self._extruder_configuration.isValid():
             return self._extruder_configuration
         return None
 
-    def updateIsPreheating(self, pre_heating):
+    def updateIsPreheating(self, pre_heating: bool) -> None:
         if self._is_preheating != pre_heating:
             self._is_preheating = pre_heating
             self.isPreheatingChanged.emit()
 
     @pyqtProperty(bool, notify=isPreheatingChanged)
-    def isPreheating(self):
+    def isPreheating(self) -> bool:
         return self._is_preheating
 
     ##  Pre-heats the extruder before printer.
@@ -113,9 +106,9 @@ class ExtruderOutputModel(QObject):
     #   Celsius.
     #   \param duration How long the bed should stay warm, in seconds.
     @pyqtSlot(float, float)
-    def preheatHotend(self, temperature, duration):
+    def preheatHotend(self, temperature: float, duration: float) -> None:
         self._printer._controller.preheatHotend(self, temperature, duration)
 
     @pyqtSlot()
-    def cancelPreheatHotend(self):
-        self._printer._controller.cancelPreheatHotend(self)
+    def cancelPreheatHotend(self) -> None:
+        self._printer._controller.cancelPreheatHotend(self)

cura/PrinterOutput/FirmwareUpdater.py

@@ -0,0 +1,78 @@
+# 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 enum import IntEnum
+from threading import Thread
+from typing import Union
+
+MYPY = False
+if MYPY:
+    from cura.PrinterOutputDevice import PrinterOutputDevice
+
+class FirmwareUpdater(QObject):
+    firmwareProgressChanged = pyqtSignal()
+    firmwareUpdateStateChanged = pyqtSignal()
+
+    def __init__(self, output_device: "PrinterOutputDevice") -> None:
+        super().__init__()
+
+        self._output_device = output_device
+
+        self._update_firmware_thread = Thread(target=self._updateFirmware, daemon=True)
+
+        self._firmware_file = ""
+        self._firmware_progress = 0
+        self._firmware_update_state = FirmwareUpdateState.idle
+
+    def updateFirmware(self, firmware_file: Union[str, QUrl]) -> None:
+        # the file path could be url-encoded.
+        if firmware_file.startswith("file://"):
+            self._firmware_file = QUrl(firmware_file).toLocalFile()
+        else:
+            self._firmware_file = firmware_file
+
+        self._setFirmwareUpdateState(FirmwareUpdateState.updating)
+
+        self._update_firmware_thread.start()
+
+    def _updateFirmware(self) -> None:
+        raise NotImplementedError("_updateFirmware needs to be implemented")
+
+    ##  Cleanup after a succesful update
+    def _cleanupAfterUpdate(self) -> None:
+        # Clean up for next attempt.
+        self._update_firmware_thread = Thread(target=self._updateFirmware, daemon=True)
+        self._firmware_file = ""
+        self._onFirmwareProgress(100)
+        self._setFirmwareUpdateState(FirmwareUpdateState.completed)
+
+    @pyqtProperty(int, notify = firmwareProgressChanged)
+    def firmwareProgress(self) -> int:
+        return self._firmware_progress
+
+    @pyqtProperty(int, notify=firmwareUpdateStateChanged)
+    def firmwareUpdateState(self) -> "FirmwareUpdateState":
+        return self._firmware_update_state
+
+    def _setFirmwareUpdateState(self, state: "FirmwareUpdateState") -> None:
+        if self._firmware_update_state != state:
+            self._firmware_update_state = state
+            self.firmwareUpdateStateChanged.emit()
+
+    # Callback function for firmware update progress.
+    def _onFirmwareProgress(self, progress: int, max_progress: int = 100) -> None:
+        self._firmware_progress = int(progress * 100 / max_progress)   # Convert to scale of 0-100
+        self.firmwareProgressChanged.emit()
+
+
+class FirmwareUpdateState(IntEnum):
+    idle = 0
+    updating = 1
+    completed = 2
+    unknown_error = 3
+    communication_error = 4
+    io_error = 5
+    firmware_not_found_error = 6
+

cura/PrinterOutput/GenericOutputController.py

@@ -1,7 +1,7 @@
 # Copyright (c) 2018 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Set, Union, Optional
 
 from cura.PrinterOutput.PrinterOutputController import PrinterOutputController
 from PyQt5.QtCore import QTimer
@@ -9,27 +9,28 @@ from PyQt5.QtCore import QTimer
 if TYPE_CHECKING:
     from cura.PrinterOutput.PrintJobOutputModel import PrintJobOutputModel
     from cura.PrinterOutput.PrinterOutputModel import PrinterOutputModel
+    from cura.PrinterOutput.PrinterOutputDevice import PrinterOutputDevice
     from cura.PrinterOutput.ExtruderOutputModel import ExtruderOutputModel
 
 
 class GenericOutputController(PrinterOutputController):
-    def __init__(self, output_device):
+    def __init__(self, output_device: "PrinterOutputDevice") -> None:
         super().__init__(output_device)
 
         self._preheat_bed_timer = QTimer()
         self._preheat_bed_timer.setSingleShot(True)
         self._preheat_bed_timer.timeout.connect(self._onPreheatBedTimerFinished)
-        self._preheat_printer = None
+        self._preheat_printer = None  # type: Optional[PrinterOutputModel]
 
         self._preheat_hotends_timer = QTimer()
         self._preheat_hotends_timer.setSingleShot(True)
         self._preheat_hotends_timer.timeout.connect(self._onPreheatHotendsTimerFinished)
-        self._preheat_hotends = set()
+        self._preheat_hotends = set()  # type: Set[ExtruderOutputModel]
 
         self._output_device.printersChanged.connect(self._onPrintersChanged)
-        self._active_printer = None
+        self._active_printer = None  # type: Optional[PrinterOutputModel]
 
-    def _onPrintersChanged(self):
+    def _onPrintersChanged(self) -> None:
         if self._active_printer:
             self._active_printer.stateChanged.disconnect(self._onPrinterStateChanged)
             self._active_printer.targetBedTemperatureChanged.disconnect(self._onTargetBedTemperatureChanged)
@@ -43,32 +44,33 @@ class GenericOutputController(PrinterOutputController):
             for extruder in self._active_printer.extruders:
                 extruder.targetHotendTemperatureChanged.connect(self._onTargetHotendTemperatureChanged)
 
-    def _onPrinterStateChanged(self):
-        if self._active_printer.state != "idle":
+    def _onPrinterStateChanged(self) -> None:
+        if self._active_printer and self._active_printer.state != "idle":
             if self._preheat_bed_timer.isActive():
                 self._preheat_bed_timer.stop()
-                self._preheat_printer.updateIsPreheating(False)
+                if self._preheat_printer:
+                    self._preheat_printer.updateIsPreheating(False)
             if self._preheat_hotends_timer.isActive():
                 self._preheat_hotends_timer.stop()
                 for extruder in self._preheat_hotends:
                     extruder.updateIsPreheating(False)
-                self._preheat_hotends = set()
+                self._preheat_hotends = set()  # type: Set[ExtruderOutputModel]
 
-    def moveHead(self, printer: "PrinterOutputModel", x, y, z, speed):
+    def moveHead(self, printer: "PrinterOutputModel", x, y, z, speed) -> None:
         self._output_device.sendCommand("G91")
         self._output_device.sendCommand("G0 X%s Y%s Z%s F%s" % (x, y, z, speed))
         self._output_device.sendCommand("G90")
 
-    def homeHead(self, printer):
+    def homeHead(self, printer: "PrinterOutputModel") -> None:
         self._output_device.sendCommand("G28 X Y")
 
-    def homeBed(self, printer):
+    def homeBed(self, printer: "PrinterOutputModel") -> None:
         self._output_device.sendCommand("G28 Z")
 
-    def sendRawCommand(self, printer: "PrinterOutputModel", command: str):
-        self._output_device.sendCommand(command)
+    def sendRawCommand(self, printer: "PrinterOutputModel", command: str) -> None:
+        self._output_device.sendCommand(command.upper()) #Most printers only understand uppercase g-code commands.
 
-    def setJobState(self, job: "PrintJobOutputModel", state: str):
+    def setJobState(self, job: "PrintJobOutputModel", state: str) -> None:
         if state == "pause":
             self._output_device.pausePrint()
             job.updateState("paused")
@@ -79,42 +81,46 @@ class GenericOutputController(PrinterOutputController):
             self._output_device.cancelPrint()
             pass
 
-    def setTargetBedTemperature(self, printer: "PrinterOutputModel", temperature: int):
-        self._output_device.sendCommand("M140 S%s" % temperature)
+    def setTargetBedTemperature(self, printer: "PrinterOutputModel", temperature: float) -> None:
+        self._output_device.sendCommand("M140 S%s" % round(temperature)) # The API doesn't allow floating point.
 
-    def _onTargetBedTemperatureChanged(self):
-        if self._preheat_bed_timer.isActive() and self._preheat_printer.targetBedTemperature == 0:
+    def _onTargetBedTemperatureChanged(self) -> None:
+        if self._preheat_bed_timer.isActive() and self._preheat_printer and self._preheat_printer.targetBedTemperature == 0:
             self._preheat_bed_timer.stop()
             self._preheat_printer.updateIsPreheating(False)
 
-    def preheatBed(self, printer: "PrinterOutputModel", temperature, duration):
+    def preheatBed(self, printer: "PrinterOutputModel", temperature, duration) -> None:
         try:
             temperature = round(temperature)  # The API doesn't allow floating point.
             duration = round(duration)
         except ValueError:
             return  # Got invalid values, can't pre-heat.
 
-        self.setTargetBedTemperature(printer, temperature=temperature)
+        self.setTargetBedTemperature(printer, temperature = temperature)
         self._preheat_bed_timer.setInterval(duration * 1000)
         self._preheat_bed_timer.start()
         self._preheat_printer = printer
         printer.updateIsPreheating(True)
 
-    def cancelPreheatBed(self, printer: "PrinterOutputModel"):
-        self.setTargetBedTemperature(printer, temperature=0)
+    def cancelPreheatBed(self, printer: "PrinterOutputModel") -> None:
+        self.setTargetBedTemperature(printer, temperature = 0)
         self._preheat_bed_timer.stop()
         printer.updateIsPreheating(False)
 
-    def _onPreheatBedTimerFinished(self):
+    def _onPreheatBedTimerFinished(self) -> None:
+        if not self._preheat_printer:
+            return
         self.setTargetBedTemperature(self._preheat_printer, 0)
         self._preheat_printer.updateIsPreheating(False)
 
-    def setTargetHotendTemperature(self, printer: "PrinterOutputModel", position: int, temperature: int):
+    def setTargetHotendTemperature(self, printer: "PrinterOutputModel", position: int, temperature: Union[int, float]) -> None:
         self._output_device.sendCommand("M104 S%s T%s" % (temperature, position))
 
-    def _onTargetHotendTemperatureChanged(self):
+    def _onTargetHotendTemperatureChanged(self) -> None:
         if not self._preheat_hotends_timer.isActive():
             return
+        if not self._active_printer:
+            return
 
         for extruder in self._active_printer.extruders:
             if extruder in self._preheat_hotends and extruder.targetHotendTemperature == 0:
@@ -123,7 +129,7 @@ class GenericOutputController(PrinterOutputController):
         if not self._preheat_hotends:
             self._preheat_hotends_timer.stop()
 
-    def preheatHotend(self, extruder: "ExtruderOutputModel", temperature, duration):
+    def preheatHotend(self, extruder: "ExtruderOutputModel", temperature, duration) -> None:
         position = extruder.getPosition()
         number_of_extruders = len(extruder.getPrinter().extruders)
         if position >= number_of_extruders:
@@ -141,7 +147,7 @@ class GenericOutputController(PrinterOutputController):
         self._preheat_hotends.add(extruder)
         extruder.updateIsPreheating(True)
 
-    def cancelPreheatHotend(self, extruder: "ExtruderOutputModel"):
+    def cancelPreheatHotend(self, extruder: "ExtruderOutputModel") -> None:
         self.setTargetHotendTemperature(extruder.getPrinter(), extruder.getPosition(), temperature=0)
         if extruder in self._preheat_hotends:
             extruder.updateIsPreheating(False)
@@ -149,21 +155,22 @@ class GenericOutputController(PrinterOutputController):
         if not self._preheat_hotends and self._preheat_hotends_timer.isActive():
             self._preheat_hotends_timer.stop()
 
-    def _onPreheatHotendsTimerFinished(self):
+    def _onPreheatHotendsTimerFinished(self) -> None:
         for extruder in self._preheat_hotends:
             self.setTargetHotendTemperature(extruder.getPrinter(), extruder.getPosition(), 0)
-        self._preheat_hotends = set()
+        self._preheat_hotends = set() #type: Set[ExtruderOutputModel]
 
     # Cancel any ongoing preheating timers, without setting back the temperature to 0
     # This can be used eg at the start of a print
-    def stopPreheatTimers(self):
+    def stopPreheatTimers(self) -> None:
         if self._preheat_hotends_timer.isActive():
             for extruder in self._preheat_hotends:
                 extruder.updateIsPreheating(False)
-            self._preheat_hotends = set()
+            self._preheat_hotends = set() #type: Set[ExtruderOutputModel]
 
             self._preheat_hotends_timer.stop()
 
         if self._preheat_bed_timer.isActive():
-            self._preheat_printer.updateIsPreheating(False)
+            if self._preheat_printer:
+                self._preheat_printer.updateIsPreheating(False)
             self._preheat_bed_timer.stop()

cura/PrinterOutput/NetworkCamera.py

@@ -1,119 +0,0 @@
-from UM.Logger import Logger
-
-from PyQt5.QtCore import QUrl, pyqtProperty, pyqtSignal, QObject, pyqtSlot
-from PyQt5.QtGui import QImage
-from PyQt5.QtNetwork import QNetworkRequest, QNetworkReply, QNetworkAccessManager
-
-
-class NetworkCamera(QObject):
-    newImage = pyqtSignal()
-
-    def __init__(self, target = None, parent = None):
-        super().__init__(parent)
-        self._stream_buffer = b""
-        self._stream_buffer_start_index = -1
-        self._manager = None
-        self._image_request = None
-        self._image_reply = None
-        self._image = QImage()
-        self._image_id = 0
-
-        self._target = target
-        self._started = False
-
-    @pyqtSlot(str)
-    def setTarget(self, target):
-        restart_required = False
-        if self._started:
-            self.stop()
-            restart_required = True
-
-        self._target = target
-
-        if restart_required:
-            self.start()
-
-    @pyqtProperty(QUrl, notify=newImage)
-    def latestImage(self):
-        self._image_id += 1
-        # There is an image provider that is called "camera". In order to ensure that the image qml object, that
-        # requires a QUrl to function, updates correctly we add an increasing number. This causes to see the QUrl
-        # as new (instead of relying on cached version and thus forces an update.
-        temp = "image://camera/" + str(self._image_id)
-
-        return QUrl(temp, QUrl.TolerantMode)
-
-    @pyqtSlot()
-    def start(self):
-        # Ensure that previous requests (if any) are stopped.
-        self.stop()
-        if self._target is None:
-            Logger.log("w", "Unable to start camera stream without target!")
-            return
-        self._started = True
-        url = QUrl(self._target)
-        self._image_request = QNetworkRequest(url)
-        if self._manager is None:
-            self._manager = QNetworkAccessManager()
-
-        self._image_reply = self._manager.get(self._image_request)
-        self._image_reply.downloadProgress.connect(self._onStreamDownloadProgress)
-
-    @pyqtSlot()
-    def stop(self):
-        self._stream_buffer = b""
-        self._stream_buffer_start_index = -1
-
-        if self._image_reply:
-            try:
-                # disconnect the signal
-                try:
-                    self._image_reply.downloadProgress.disconnect(self._onStreamDownloadProgress)
-                except Exception:
-                    pass
-                # abort the request if it's not finished
-                if not self._image_reply.isFinished():
-                    self._image_reply.close()
-            except Exception as e:  # RuntimeError
-                pass  # It can happen that the wrapped c++ object is already deleted.
-
-            self._image_reply = None
-            self._image_request = None
-
-        self._manager = None
-
-        self._started = False
-
-    def getImage(self):
-        return self._image
-
-    ##  Ensure that close gets called when object is destroyed
-    def __del__(self):
-        self.stop()
-
-    def _onStreamDownloadProgress(self, bytes_received, bytes_total):
-        # An MJPG stream is (for our purpose) a stream of concatenated JPG images.
-        # JPG images start with the marker 0xFFD8, and end with 0xFFD9
-        if self._image_reply is None:
-            return
-        self._stream_buffer += self._image_reply.readAll()
-
-        if len(self._stream_buffer) > 2000000:  # No single camera frame should be 2 Mb or larger
-            Logger.log("w", "MJPEG buffer exceeds reasonable size. Restarting stream...")
-            self.stop()  # resets stream buffer and start index
-            self.start()
-            return
-
-        if self._stream_buffer_start_index == -1:
-            self._stream_buffer_start_index = self._stream_buffer.indexOf(b'\xff\xd8')
-        stream_buffer_end_index = self._stream_buffer.lastIndexOf(b'\xff\xd9')
-        # If this happens to be more than a single frame, then so be it; the JPG decoder will
-        # ignore the extra data. We do it like this in order not to get a buildup of frames
-
-        if self._stream_buffer_start_index != -1 and stream_buffer_end_index != -1:
-            jpg_data = self._stream_buffer[self._stream_buffer_start_index:stream_buffer_end_index + 2]
-            self._stream_buffer = self._stream_buffer[stream_buffer_end_index + 2:]
-            self._stream_buffer_start_index = -1
-            self._image.loadFromData(jpg_data)
-
-        self.newImage.emit()

cura/PrinterOutput/NetworkMJPGImage.py

@@ -0,0 +1,153 @@
+# Copyright (c) 2018 Aldo Hoeben / fieldOfView
+# NetworkMJPGImage is released under the terms of the LGPLv3 or higher.
+
+from PyQt5.QtCore import QUrl, pyqtProperty, pyqtSignal, pyqtSlot, QRect, QByteArray
+from PyQt5.QtGui import QImage, QPainter
+from PyQt5.QtQuick import QQuickPaintedItem
+from PyQt5.QtNetwork import QNetworkRequest, QNetworkReply, QNetworkAccessManager
+
+from UM.Logger import Logger
+
+#
+# A QQuickPaintedItem that progressively downloads a network mjpeg stream,
+# picks it apart in individual jpeg frames, and paints it.
+#
+class NetworkMJPGImage(QQuickPaintedItem):
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+
+        self._stream_buffer = QByteArray()
+        self._stream_buffer_start_index = -1
+        self._network_manager = None  # type: QNetworkAccessManager
+        self._image_request = None  # type: QNetworkRequest
+        self._image_reply = None  # type: QNetworkReply
+        self._image = QImage()
+        self._image_rect = QRect()
+
+        self._source_url = QUrl()
+        self._started = False
+
+        self._mirror = False
+
+        self.setAntialiasing(True)
+
+    ##  Ensure that close gets called when object is destroyed
+    def __del__(self) -> None:
+        self.stop()
+
+
+    def paint(self, painter: "QPainter") -> None:
+        if self._mirror:
+            painter.drawImage(self.contentsBoundingRect(), self._image.mirrored())
+            return
+
+        painter.drawImage(self.contentsBoundingRect(), self._image)
+
+
+    def setSourceURL(self, source_url: "QUrl") -> None:
+        self._source_url = source_url
+        self.sourceURLChanged.emit()
+        if self._started:
+            self.start()
+
+    def getSourceURL(self) -> "QUrl":
+        return self._source_url
+
+    sourceURLChanged = pyqtSignal()
+    source = pyqtProperty(QUrl, fget = getSourceURL, fset = setSourceURL, notify = sourceURLChanged)
+
+    def setMirror(self, mirror: bool) -> None:
+        if mirror == self._mirror:
+            return
+        self._mirror = mirror
+        self.mirrorChanged.emit()
+        self.update()
+
+    def getMirror(self) -> bool:
+        return self._mirror
+
+    mirrorChanged = pyqtSignal()
+    mirror = pyqtProperty(bool, fget = getMirror, fset = setMirror, notify = mirrorChanged)
+
+    imageSizeChanged = pyqtSignal()
+
+    @pyqtProperty(int, notify = imageSizeChanged)
+    def imageWidth(self) -> int:
+        return self._image.width()
+
+    @pyqtProperty(int, notify = imageSizeChanged)
+    def imageHeight(self) -> int:
+        return self._image.height()
+
+
+    @pyqtSlot()
+    def start(self) -> None:
+        self.stop()  # Ensure that previous requests (if any) are stopped.
+
+        if not self._source_url:
+            Logger.log("w", "Unable to start camera stream without target!")
+            return
+        self._started = True
+
+        self._image_request = QNetworkRequest(self._source_url)
+        if self._network_manager is None:
+            self._network_manager = QNetworkAccessManager()
+
+        self._image_reply = self._network_manager.get(self._image_request)
+        self._image_reply.downloadProgress.connect(self._onStreamDownloadProgress)
+
+    @pyqtSlot()
+    def stop(self) -> None:
+        self._stream_buffer = QByteArray()
+        self._stream_buffer_start_index = -1
+
+        if self._image_reply:
+            try:
+                try:
+                    self._image_reply.downloadProgress.disconnect(self._onStreamDownloadProgress)
+                except Exception:
+                    pass
+
+                if not self._image_reply.isFinished():
+                    self._image_reply.close()
+            except Exception as e:  # RuntimeError
+                pass  # It can happen that the wrapped c++ object is already deleted.
+
+            self._image_reply = None
+            self._image_request = None
+
+        self._network_manager = None
+
+        self._started = False
+
+
+    def _onStreamDownloadProgress(self, bytes_received: int, bytes_total: int) -> None:
+        # An MJPG stream is (for our purpose) a stream of concatenated JPG images.
+        # JPG images start with the marker 0xFFD8, and end with 0xFFD9
+        if self._image_reply is None:
+            return
+        self._stream_buffer += self._image_reply.readAll()
+
+        if len(self._stream_buffer) > 2000000:  # No single camera frame should be 2 Mb or larger
+            Logger.log("w", "MJPEG buffer exceeds reasonable size. Restarting stream...")
+            self.stop()  # resets stream buffer and start index
+            self.start()
+            return
+
+        if self._stream_buffer_start_index == -1:
+            self._stream_buffer_start_index = self._stream_buffer.indexOf(b'\xff\xd8')
+        stream_buffer_end_index = self._stream_buffer.lastIndexOf(b'\xff\xd9')
+        # If this happens to be more than a single frame, then so be it; the JPG decoder will
+        # ignore the extra data. We do it like this in order not to get a buildup of frames
+
+        if self._stream_buffer_start_index != -1 and stream_buffer_end_index != -1:
+            jpg_data = self._stream_buffer[self._stream_buffer_start_index:stream_buffer_end_index + 2]
+            self._stream_buffer = self._stream_buffer[stream_buffer_end_index + 2:]
+            self._stream_buffer_start_index = -1
+            self._image.loadFromData(jpg_data)
+
+            if self._image.rect() != self._image_rect:
+                self.imageSizeChanged.emit()
+
+            self.update()

cura/PrinterOutput/NetworkedPrinterOutputDevice.py

@@ -4,19 +4,21 @@
 from UM.FileHandler.FileHandler import FileHandler #For typing.
 from UM.Logger import Logger
 from UM.Scene.SceneNode import SceneNode #For typing.
+from cura.API import Account
 from cura.CuraApplication import CuraApplication
 
-from cura.PrinterOutputDevice import PrinterOutputDevice, ConnectionState
+from cura.PrinterOutputDevice import PrinterOutputDevice, ConnectionState, ConnectionType
 
 from PyQt5.QtNetwork import QHttpMultiPart, QHttpPart, QNetworkRequest, QNetworkAccessManager, QNetworkReply, QAuthenticator
 from PyQt5.QtCore import pyqtProperty, pyqtSignal, pyqtSlot, QObject, QUrl, QCoreApplication
 from time import time
-from typing import Any, Callable, Dict, List, Optional
+from typing import Callable, Dict, List, Optional, Union
 from enum import IntEnum
 
 import os  # To get the username
 import gzip
 
+
 class AuthState(IntEnum):
     NotAuthenticated = 1
     AuthenticationRequested = 2
@@ -28,8 +30,8 @@ class AuthState(IntEnum):
 class NetworkedPrinterOutputDevice(PrinterOutputDevice):
     authenticationStateChanged = pyqtSignal()
 
-    def __init__(self, device_id, address: str, properties: Dict[bytes, bytes], parent: QObject = None) -> None:
-        super().__init__(device_id = device_id, parent = parent)
+    def __init__(self, device_id, address: str, properties: Dict[bytes, bytes], connection_type: ConnectionType = ConnectionType.NetworkConnection, parent: QObject = None) -> None:
+        super().__init__(device_id = device_id, connection_type = connection_type, parent = parent)
         self._manager = None    # type: Optional[QNetworkAccessManager]
         self._last_manager_create_time = None       # type: Optional[float]
         self._recreate_network_manager_time = 30
@@ -41,7 +43,8 @@ class NetworkedPrinterOutputDevice(PrinterOutputDevice):
         self._api_prefix = ""
         self._address = address
         self._properties = properties
-        self._user_agent = "%s/%s " % (CuraApplication.getInstance().getApplicationName(), CuraApplication.getInstance().getVersion())
+        self._user_agent = "%s/%s " % (CuraApplication.getInstance().getApplicationName(),
+                                       CuraApplication.getInstance().getVersion())
 
         self._onFinishedCallbacks = {}      # type: Dict[str, Callable[[QNetworkReply], None]]
         self._authentication_state = AuthState.NotAuthenticated
@@ -53,22 +56,10 @@ class NetworkedPrinterOutputDevice(PrinterOutputDevice):
         self._sending_gcode = False
         self._compressing_gcode = False
         self._gcode = []                    # type: List[str]
-
         self._connection_state_before_timeout = None    # type: Optional[ConnectionState]
 
-        printer_type = self._properties.get(b"machine", b"").decode("utf-8")
-        printer_type_identifiers = {
-            "9066": "ultimaker3",
-            "9511": "ultimaker3_extended",
-            "9051": "ultimaker_s5"
-        }
-        self._printer_type = "Unknown"
-        for key, value in printer_type_identifiers.items():
-            if printer_type.startswith(key):
-                self._printer_type = value
-                break
-
-    def requestWrite(self, nodes: List[SceneNode], file_name: Optional[str] = None, limit_mimetypes: bool = False, file_handler: Optional[FileHandler] = None, **kwargs: str) -> None:
+    def requestWrite(self, nodes: List[SceneNode], file_name: Optional[str] = None, limit_mimetypes: bool = False,
+                     file_handler: Optional[FileHandler] = None, **kwargs: str) -> None:
         raise NotImplementedError("requestWrite needs to be implemented")
 
     def setAuthenticationState(self, authentication_state: AuthState) -> None:
@@ -138,17 +129,15 @@ class NetworkedPrinterOutputDevice(PrinterOutputDevice):
             if self._connection_state_before_timeout is None:
                 self._connection_state_before_timeout = self._connection_state
 
-            self.setConnectionState(ConnectionState.closed)
+            self.setConnectionState(ConnectionState.Closed)
 
             # We need to check if the manager needs to be re-created. If we don't, we get some issues when OSX goes to
             # sleep.
             if time_since_last_response > self._recreate_network_manager_time:
-                if self._last_manager_create_time is None:
-                    self._createNetworkManager()
-                elif time() - self._last_manager_create_time > self._recreate_network_manager_time:
+                if self._last_manager_create_time is None or time() - self._last_manager_create_time > self._recreate_network_manager_time:
                     self._createNetworkManager()
                 assert(self._manager is not None)
-        elif self._connection_state == ConnectionState.closed:
+        elif self._connection_state == ConnectionState.Closed:
             # Go out of timeout.
             if self._connection_state_before_timeout is not None:   # sanity check, but it should never be None here
                 self.setConnectionState(self._connection_state_before_timeout)
@@ -158,10 +147,15 @@ class NetworkedPrinterOutputDevice(PrinterOutputDevice):
         url = QUrl("http://" + self._address + self._api_prefix + target)
         request = QNetworkRequest(url)
         if content_type is not None:
-            request.setHeader(QNetworkRequest.ContentTypeHeader, "application/json")
+            request.setHeader(QNetworkRequest.ContentTypeHeader, content_type)
         request.setHeader(QNetworkRequest.UserAgentHeader, self._user_agent)
         return request
 
+    ##  This method was only available privately before, but it was actually called from SendMaterialJob.py.
+    #   We now have a public equivalent as well. We did not remove the private one as plugins might be using that.
+    def createFormPart(self, content_header: str, data: bytes, content_type: Optional[str] = None) -> QHttpPart:
+        return self._createFormPart(content_header, data, content_type)
+
     def _createFormPart(self, content_header: str, data: bytes, content_type: Optional[str] = None) -> QHttpPart:
         part = QHttpPart()
 
@@ -175,9 +169,15 @@ class NetworkedPrinterOutputDevice(PrinterOutputDevice):
         part.setBody(data)
         return part
 
-    ##  Convenience function to get the username from the OS.
-    #   The code was copied from the getpass module, as we try to use as little dependencies as possible.
+    ##  Convenience function to get the username, either from the cloud or from the OS.
     def _getUserName(self) -> str:
+        # check first if we are logged in with the Ultimaker Account
+        account = CuraApplication.getInstance().getCuraAPI().account  # type: Account
+        if account and account.isLoggedIn:
+            return account.userName
+
+        # Otherwise get the username from the US
+        # The code below was copied from the getpass module, as we try to use as little dependencies as possible.
         for name in ("LOGNAME", "USER", "LNAME", "USERNAME"):
             user = os.environ.get(name)
             if user:
@@ -188,40 +188,95 @@ class NetworkedPrinterOutputDevice(PrinterOutputDevice):
         if reply in self._kept_alive_multiparts:
             del self._kept_alive_multiparts[reply]
 
-    def put(self, target: str, data: str, on_finished: Optional[Callable[[QNetworkReply], None]]) -> None:
+    def _validateManager(self) -> None:
         if self._manager is None:
             self._createNetworkManager()
         assert (self._manager is not None)
-        request = self._createEmptyRequest(target)
+
+    ## Sends a put request to the given path.
+    #  \param url: The path after the API prefix.
+    #  \param data: The data to be sent in the body
+    #  \param content_type: The content type of the body data.
+    #  \param on_finished: The function to call when the response is received.
+    #  \param on_progress: The function to call when the progress changes. Parameters are bytes_sent / bytes_total.
+    def put(self, url: str, data: Union[str, bytes], content_type: Optional[str] = "application/json",
+            on_finished: Optional[Callable[[QNetworkReply], None]] = None,
+            on_progress: Optional[Callable[[int, int], None]] = None) -> None:
+        self._validateManager()
+
+        request = self._createEmptyRequest(url, content_type = content_type)
         self._last_request_time = time()
-        reply = self._manager.put(request, data.encode())
+
+        if not self._manager:
+            Logger.log("e", "No network manager was created to execute the PUT call with.")
+            return
+
+        body = data if isinstance(data, bytes) else data.encode()  # type: bytes
+        reply = self._manager.put(request, body)
         self._registerOnFinishedCallback(reply, on_finished)
 
-    def get(self, target: str, on_finished: Optional[Callable[[QNetworkReply], None]]) -> None:
-        if self._manager is None:
-            self._createNetworkManager()
-        assert (self._manager is not None)
-        request = self._createEmptyRequest(target)
+        if on_progress is not None:
+            reply.uploadProgress.connect(on_progress)
+
+    ## Sends a delete request to the given path.
+    #  \param url: The path after the API prefix.
+    #  \param on_finished: The function to be call when the response is received.
+    def delete(self, url: str, on_finished: Optional[Callable[[QNetworkReply], None]]) -> None:
+        self._validateManager()
+
+        request = self._createEmptyRequest(url)
         self._last_request_time = time()
+
+        if not self._manager:
+            Logger.log("e", "No network manager was created to execute the DELETE call with.")
+            return
+
+        reply = self._manager.deleteResource(request)
+        self._registerOnFinishedCallback(reply, on_finished)
+
+    ## Sends a get request to the given path.
+    #  \param url: The path after the API prefix.
+    #  \param on_finished: The function to be call when the response is received.
+    def get(self, url: str, on_finished: Optional[Callable[[QNetworkReply], None]]) -> None:
+        self._validateManager()
+
+        request = self._createEmptyRequest(url)
+        self._last_request_time = time()
+
+        if not self._manager:
+            Logger.log("e", "No network manager was created to execute the GET call with.")
+            return
+
         reply = self._manager.get(request)
         self._registerOnFinishedCallback(reply, on_finished)
 
-    def post(self, target: str, data: str, on_finished: Optional[Callable[[QNetworkReply], None]], on_progress: Callable = None) -> None:
-        if self._manager is None:
-            self._createNetworkManager()
-        assert (self._manager is not None)
-        request = self._createEmptyRequest(target)
+    ## Sends a post request to the given path.
+    #  \param url: The path after the API prefix.
+    #  \param data: The data to be sent in the body
+    #  \param on_finished: The function to call when the response is received.
+    #  \param on_progress: The function to call when the progress changes. Parameters are bytes_sent / bytes_total.
+    def post(self, url: str, data: Union[str, bytes],
+             on_finished: Optional[Callable[[QNetworkReply], None]],
+             on_progress: Optional[Callable[[int, int], None]] = None) -> None:
+        self._validateManager()
+
+        request = self._createEmptyRequest(url)
         self._last_request_time = time()
-        reply = self._manager.post(request, data)
+
+        if not self._manager:
+            Logger.log("e", "Could not find manager.")
+            return
+
+        body = data if isinstance(data, bytes) else data.encode()  # type: bytes
+        reply = self._manager.post(request, body)
         if on_progress is not None:
             reply.uploadProgress.connect(on_progress)
         self._registerOnFinishedCallback(reply, on_finished)
 
-    def postFormWithParts(self, target: str, parts: List[QHttpPart], on_finished: Optional[Callable[[QNetworkReply], None]], on_progress: Callable = None) -> QNetworkReply:
-
-        if self._manager is None:
-            self._createNetworkManager()
-        assert (self._manager is not None)
+    def postFormWithParts(self, target: str, parts: List[QHttpPart],
+                          on_finished: Optional[Callable[[QNetworkReply], None]],
+                          on_progress: Optional[Callable[[int, int], None]] = None) -> QNetworkReply:
+        self._validateManager()
         request = self._createEmptyRequest(target, content_type=None)
         multi_post_part = QHttpMultiPart(QHttpMultiPart.FormDataType)
         for part in parts:
@@ -229,15 +284,18 @@ class NetworkedPrinterOutputDevice(PrinterOutputDevice):
 
         self._last_request_time = time()
 
-        reply = self._manager.post(request, multi_post_part)
+        if self._manager is not None:
+            reply = self._manager.post(request, multi_post_part)
 
-        self._kept_alive_multiparts[reply] = multi_post_part
+            self._kept_alive_multiparts[reply] = multi_post_part
 
-        if on_progress is not None:
-            reply.uploadProgress.connect(on_progress)
-        self._registerOnFinishedCallback(reply, on_finished)
+            if on_progress is not None:
+                reply.uploadProgress.connect(on_progress)
+            self._registerOnFinishedCallback(reply, on_finished)
 
-        return reply
+            return reply
+        else:
+            Logger.log("e", "Could not find manager.")
 
     def postForm(self, target: str, header_data: str, body_data: bytes, on_finished: Optional[Callable[[QNetworkReply], None]], on_progress: Callable = None) -> None:
         post_part = QHttpPart()
@@ -252,11 +310,11 @@ class NetworkedPrinterOutputDevice(PrinterOutputDevice):
     def _createNetworkManager(self) -> None:
         Logger.log("d", "Creating network manager")
         if self._manager:
-            self._manager.finished.disconnect(self.__handleOnFinished)
+            self._manager.finished.disconnect(self._handleOnFinished)
             self._manager.authenticationRequired.disconnect(self._onAuthenticationRequired)
 
         self._manager = QNetworkAccessManager()
-        self._manager.finished.connect(self.__handleOnFinished)
+        self._manager.finished.connect(self._handleOnFinished)
         self._last_manager_create_time = time()
         self._manager.authenticationRequired.connect(self._onAuthenticationRequired)
 
@@ -267,7 +325,7 @@ class NetworkedPrinterOutputDevice(PrinterOutputDevice):
         if on_finished is not None:
             self._onFinishedCallbacks[reply.url().toString() + str(reply.operation())] = on_finished
 
-    def __handleOnFinished(self, reply: QNetworkReply) -> None:
+    def _handleOnFinished(self, reply: QNetworkReply) -> None:
         # Due to garbage collection, we need to cache certain bits of post operations.
         # As we don't want to keep them around forever, delete them if we get a reply.
         if reply.operation() == QNetworkAccessManager.PostOperation:
@@ -279,8 +337,8 @@ class NetworkedPrinterOutputDevice(PrinterOutputDevice):
 
         self._last_response_time = time()
 
-        if self._connection_state == ConnectionState.connecting:
-            self.setConnectionState(ConnectionState.connected)
+        if self._connection_state == ConnectionState.Connecting:
+            self.setConnectionState(ConnectionState.Connected)
 
         callback_key = reply.url().toString() + str(reply.operation())
         try:
@@ -323,7 +381,7 @@ class NetworkedPrinterOutputDevice(PrinterOutputDevice):
 
     @pyqtProperty(str, constant = True)
     def printerType(self) -> str:
-        return self._printer_type
+        return self._properties.get(b"printer_type", b"Unknown").decode("utf-8")
 
     ## IP adress of this printer
     @pyqtProperty(str, constant = True)

cura/PrinterOutput/PrintJobOutputModel.py

@@ -1,12 +1,16 @@
-# Copyright (c) 2017 Ultimaker B.V.
+# Copyright (c) 2018 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
 
 from PyQt5.QtCore import pyqtSignal, pyqtProperty, QObject, pyqtSlot
-from typing import Optional, TYPE_CHECKING
+from typing import Optional, TYPE_CHECKING, List
+
+from PyQt5.QtCore import QUrl
+from PyQt5.QtGui import QImage
 
 if TYPE_CHECKING:
     from cura.PrinterOutput.PrinterOutputController import PrinterOutputController
     from cura.PrinterOutput.PrinterOutputModel import PrinterOutputModel
+    from cura.PrinterOutput.ConfigurationModel import ConfigurationModel
 
 
 class PrintJobOutputModel(QObject):
@@ -17,6 +21,9 @@ class PrintJobOutputModel(QObject):
     keyChanged = pyqtSignal()
     assignedPrinterChanged = pyqtSignal()
     ownerChanged = pyqtSignal()
+    configurationChanged = pyqtSignal()
+    previewImageChanged = pyqtSignal()
+    compatibleMachineFamiliesChanged = pyqtSignal()
 
     def __init__(self, output_controller: "PrinterOutputController", key: str = "", name: str = "", parent=None) -> None:
         super().__init__(parent)
@@ -29,6 +36,48 @@ class PrintJobOutputModel(QObject):
         self._assigned_printer = None  # type: Optional[PrinterOutputModel]
         self._owner = ""  # Who started/owns the print job?
 
+        self._configuration = None  # type: Optional[ConfigurationModel]
+        self._compatible_machine_families = []  # type: List[str]
+        self._preview_image_id = 0
+
+        self._preview_image = None  # type: Optional[QImage]
+
+    @pyqtProperty("QStringList", notify=compatibleMachineFamiliesChanged)
+    def compatibleMachineFamilies(self):
+        # Hack; Some versions of cluster will return a family more than once...
+        return list(set(self._compatible_machine_families))
+
+    def setCompatibleMachineFamilies(self, compatible_machine_families: List[str]) -> None:
+        if self._compatible_machine_families != compatible_machine_families:
+            self._compatible_machine_families = compatible_machine_families
+            self.compatibleMachineFamiliesChanged.emit()
+
+    @pyqtProperty(QUrl, notify=previewImageChanged)
+    def previewImageUrl(self):
+        self._preview_image_id += 1
+        # There is an image provider that is called "print_job_preview". In order to ensure that the image qml object, that
+        # requires a QUrl to function, updates correctly we add an increasing number. This causes to see the QUrl
+        # as new (instead of relying on cached version and thus forces an update.
+        temp = "image://print_job_preview/" + str(self._preview_image_id) + "/" + self._key
+        return QUrl(temp, QUrl.TolerantMode)
+
+    def getPreviewImage(self) -> Optional[QImage]:
+        return self._preview_image
+
+    def updatePreviewImage(self, preview_image: Optional[QImage]) -> None:
+        if self._preview_image != preview_image:
+            self._preview_image = preview_image
+            self.previewImageChanged.emit()
+
+    @pyqtProperty(QObject, notify=configurationChanged)
+    def configuration(self) -> Optional["ConfigurationModel"]:
+        return self._configuration
+
+    def updateConfiguration(self, configuration: Optional["ConfigurationModel"]) -> None:
+        if self._configuration != configuration:
+            self._configuration = configuration
+            self.configurationChanged.emit()
+
     @pyqtProperty(str, notify=ownerChanged)
     def owner(self):
         return self._owner
@@ -42,7 +91,7 @@ class PrintJobOutputModel(QObject):
     def assignedPrinter(self):
         return self._assigned_printer
 
-    def updateAssignedPrinter(self, assigned_printer: "PrinterOutputModel"):
+    def updateAssignedPrinter(self, assigned_printer: Optional["PrinterOutputModel"]) -> None:
         if self._assigned_printer != assigned_printer:
             old_printer = self._assigned_printer
             self._assigned_printer = assigned_printer
@@ -70,17 +119,39 @@ class PrintJobOutputModel(QObject):
             self.nameChanged.emit()
 
     @pyqtProperty(int, notify = timeTotalChanged)
-    def timeTotal(self):
+    def timeTotal(self) -> int:
         return self._time_total
 
     @pyqtProperty(int, notify = timeElapsedChanged)
-    def timeElapsed(self):
+    def timeElapsed(self) -> int:
         return self._time_elapsed
 
+    @pyqtProperty(int, notify = timeElapsedChanged)
+    def timeRemaining(self) -> int:
+        # Never get a negative time remaining
+        return max(self.timeTotal - self.timeElapsed, 0)
+
+    @pyqtProperty(float, notify = timeElapsedChanged)
+    def progress(self) -> float:
+        result = float(self.timeElapsed) / max(self.timeTotal, 1.0) # Prevent a division by zero exception.
+        return min(result, 1.0)  # Never get a progress past 1.0
+
     @pyqtProperty(str, notify=stateChanged)
-    def state(self):
+    def state(self) -> str:
         return self._state
 
+    @pyqtProperty(bool, notify=stateChanged)
+    def isActive(self) -> bool:
+        inactiveStates = [
+            "pausing",
+            "paused",
+            "resuming",
+            "wait_cleanup"
+        ]
+        if self.state in inactiveStates and self.timeRemaining > 0:
+            return False
+        return True
+
     def updateTimeTotal(self, new_time_total):
         if self._time_total != new_time_total:
             self._time_total = new_time_total
@@ -98,4 +169,4 @@ class PrintJobOutputModel(QObject):
 
     @pyqtSlot(str)
     def setState(self, state):
-        self._output_controller.setJobState(self, state)
+        self._output_controller.setJobState(self, state)

cura/PrinterOutput/PrinterOutputController.py

@@ -1,57 +1,68 @@
-# Copyright (c) 2017 Ultimaker B.V.
+# Copyright (c) 2019 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
 
 from UM.Logger import Logger
+from UM.Signal import Signal
+
+from typing import Union
 
 MYPY = False
 if MYPY:
     from cura.PrinterOutput.PrintJobOutputModel import PrintJobOutputModel
     from cura.PrinterOutput.ExtruderOutputModel import ExtruderOutputModel
     from cura.PrinterOutput.PrinterOutputModel import PrinterOutputModel
+    from cura.PrinterOutput.PrinterOutputDevice import PrinterOutputDevice
 
 
 class PrinterOutputController:
-    def __init__(self, output_device):
+    def __init__(self, output_device: "PrinterOutputDevice") -> None:
         self.can_pause = True
         self.can_abort = True
         self.can_pre_heat_bed = True
         self.can_pre_heat_hotends = True
         self.can_send_raw_gcode = True
         self.can_control_manually = True
+        self.can_update_firmware = False
         self._output_device = output_device
 
-    def setTargetHotendTemperature(self, printer: "PrinterOutputModel", extruder: "ExtruderOutputModel", temperature: int):
+    def setTargetHotendTemperature(self, printer: "PrinterOutputModel", position: int, temperature: float) -> None:
         Logger.log("w", "Set target hotend temperature not implemented in controller")
 
-    def setTargetBedTemperature(self, printer: "PrinterOutputModel", temperature: int):
+    def setTargetBedTemperature(self, printer: "PrinterOutputModel", temperature: float) -> None:
         Logger.log("w", "Set target bed temperature not implemented in controller")
 
-    def setJobState(self, job: "PrintJobOutputModel", state: str):
+    def setJobState(self, job: "PrintJobOutputModel", state: str) -> None:
         Logger.log("w", "Set job state not implemented in controller")
 
-    def cancelPreheatBed(self, printer: "PrinterOutputModel"):
+    def cancelPreheatBed(self, printer: "PrinterOutputModel") -> None:
         Logger.log("w", "Cancel preheat bed not implemented in controller")
 
-    def preheatBed(self, printer: "PrinterOutputModel", temperature, duration):
+    def preheatBed(self, printer: "PrinterOutputModel", temperature, duration) -> None:
         Logger.log("w", "Preheat bed not implemented in controller")
 
-    def cancelPreheatHotend(self, extruder: "ExtruderOutputModel"):
+    def cancelPreheatHotend(self, extruder: "ExtruderOutputModel") -> None:
         Logger.log("w", "Cancel preheat hotend not implemented in controller")
 
-    def preheatHotend(self, extruder: "ExtruderOutputModel", temperature, duration):
+    def preheatHotend(self, extruder: "ExtruderOutputModel", temperature, duration) -> None:
         Logger.log("w", "Preheat hotend not implemented in controller")
 
-    def setHeadPosition(self, printer: "PrinterOutputModel", x, y, z, speed):
+    def setHeadPosition(self, printer: "PrinterOutputModel", x, y, z, speed) -> None:
         Logger.log("w", "Set head position not implemented in controller")
 
-    def moveHead(self, printer: "PrinterOutputModel", x, y, z, speed):
+    def moveHead(self, printer: "PrinterOutputModel", x, y, z, speed) -> None:
         Logger.log("w", "Move head not implemented in controller")
 
-    def homeBed(self, printer: "PrinterOutputModel"):
+    def homeBed(self, printer: "PrinterOutputModel") -> None:
         Logger.log("w", "Home bed not implemented in controller")
 
-    def homeHead(self, printer: "PrinterOutputModel"):
+    def homeHead(self, printer: "PrinterOutputModel") -> None:
         Logger.log("w", "Home head not implemented in controller")
 
-    def sendRawCommand(self, printer: "PrinterOutputModel", command: str):
+    def sendRawCommand(self, printer: "PrinterOutputModel", command: str) -> None:
         Logger.log("w", "Custom command not implemented in controller")
+
+    canUpdateFirmwareChanged = Signal()
+    def setCanUpdateFirmware(self, can_update_firmware: bool) -> None:
+        if can_update_firmware != self.can_update_firmware:
+            self.can_update_firmware = can_update_firmware
+            self.canUpdateFirmwareChanged.emit()

cura/PrinterOutput/PrinterOutputModel.py

@@ -1,8 +1,8 @@
-# Copyright (c) 2018 Ultimaker B.V.
+# Copyright (c) 2019 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
 
-from PyQt5.QtCore import pyqtSignal, pyqtProperty, QObject, QVariant, pyqtSlot
-from typing import Optional
+from PyQt5.QtCore import pyqtSignal, pyqtProperty, QObject, QVariant, pyqtSlot, QUrl
+from typing import List, Dict, Optional
 from UM.Math.Vector import Vector
 from cura.PrinterOutput.ConfigurationModel import ConfigurationModel
 from cura.PrinterOutput.ExtruderOutputModel import ExtruderOutputModel
@@ -22,138 +22,140 @@ class PrinterOutputModel(QObject):
     nameChanged = pyqtSignal()
     headPositionChanged = pyqtSignal()
     keyChanged = pyqtSignal()
-    printerTypeChanged = pyqtSignal()
+    typeChanged = pyqtSignal()
     buildplateChanged = pyqtSignal()
-    cameraChanged = pyqtSignal()
+    cameraUrlChanged = pyqtSignal()
     configurationChanged = pyqtSignal()
+    canUpdateFirmwareChanged = pyqtSignal()
 
     def __init__(self, output_controller: "PrinterOutputController", number_of_extruders: int = 1, parent=None, firmware_version = "") -> None:
         super().__init__(parent)
-        self._bed_temperature = -1  # Use -1 for no heated bed.
-        self._target_bed_temperature = 0
+        self._bed_temperature = -1  # type: float  # Use -1 for no heated bed.
+        self._target_bed_temperature = 0 # type: float
         self._name = ""
         self._key = ""  # Unique identifier
         self._controller = output_controller
+        self._controller.canUpdateFirmwareChanged.connect(self._onControllerCanUpdateFirmwareChanged)
         self._extruders = [ExtruderOutputModel(printer = self, position = i) for i in range(number_of_extruders)]
-        self._printer_configuration = ConfigurationModel()    # Indicates the current configuration setup in this printer
+        self._printer_configuration = ConfigurationModel()  # Indicates the current configuration setup in this printer
         self._head_position = Vector(0, 0, 0)
         self._active_print_job = None  # type: Optional[PrintJobOutputModel]
         self._firmware_version = firmware_version
         self._printer_state = "unknown"
         self._is_preheating = False
         self._printer_type = ""
-        self._buildplate_name = None
-        # Update the printer configuration every time any of the extruders changes its configuration
-        for extruder in self._extruders:
-            extruder.extruderConfigurationChanged.connect(self._updateExtruderConfiguration)
+        self._buildplate = ""
 
-        self._camera = None
+        self._printer_configuration.extruderConfigurations = [extruder.extruderConfiguration for extruder in
+                                                              self._extruders]
+
+        self._camera_url = QUrl()  # type: QUrl
 
     @pyqtProperty(str, constant = True)
-    def firmwareVersion(self):
+    def firmwareVersion(self) -> str:
         return self._firmware_version
 
-    def setCamera(self, camera):
-        if self._camera is not camera:
-            self._camera = camera
-            self.cameraChanged.emit()
+    def setCameraUrl(self, camera_url: "QUrl") -> None:
+        if self._camera_url != camera_url:
+            self._camera_url = camera_url
+            self.cameraUrlChanged.emit()
 
-    def updateIsPreheating(self, pre_heating):
+    @pyqtProperty(QUrl, fset = setCameraUrl, notify = cameraUrlChanged)
+    def cameraUrl(self) -> "QUrl":
+        return self._camera_url
+
+    def updateIsPreheating(self, pre_heating: bool) -> None:
         if self._is_preheating != pre_heating:
             self._is_preheating = pre_heating
             self.isPreheatingChanged.emit()
 
     @pyqtProperty(bool, notify=isPreheatingChanged)
-    def isPreheating(self):
+    def isPreheating(self) -> bool:
         return self._is_preheating
 
-    @pyqtProperty(QObject, notify=cameraChanged)
-    def camera(self):
-        return self._camera
-
-    @pyqtProperty(str, notify = printerTypeChanged)
-    def type(self):
+    @pyqtProperty(str, notify = typeChanged)
+    def type(self) -> str:
         return self._printer_type
 
-    def updateType(self, printer_type):
+    def updateType(self, printer_type: str) -> None:
         if self._printer_type != printer_type:
             self._printer_type = printer_type
             self._printer_configuration.printerType = self._printer_type
-            self.printerTypeChanged.emit()
+            self.typeChanged.emit()
             self.configurationChanged.emit()
 
     @pyqtProperty(str, notify = buildplateChanged)
-    def buildplate(self):
-        return self._buildplate_name
+    def buildplate(self) -> str:
+        return self._buildplate
 
-    def updateBuildplateName(self, buildplate_name):
-        if self._buildplate_name != buildplate_name:
-            self._buildplate_name = buildplate_name
-            self._printer_configuration.buildplateConfiguration = self._buildplate_name
+    def updateBuildplate(self, buildplate: str) -> None:
+        if self._buildplate != buildplate:
+            self._buildplate = buildplate
+            self._printer_configuration.buildplateConfiguration = self._buildplate
             self.buildplateChanged.emit()
             self.configurationChanged.emit()
 
     @pyqtProperty(str, notify=keyChanged)
-    def key(self):
+    def key(self) -> str:
         return self._key
 
-    def updateKey(self, key: str):
+    def updateKey(self, key: str) -> None:
         if self._key != key:
             self._key = key
             self.keyChanged.emit()
 
     @pyqtSlot()
-    def homeHead(self):
+    def homeHead(self) -> None:
         self._controller.homeHead(self)
 
     @pyqtSlot()
-    def homeBed(self):
+    def homeBed(self) -> None:
         self._controller.homeBed(self)
 
     @pyqtSlot(str)
-    def sendRawCommand(self, command: str):
+    def sendRawCommand(self, command: str) -> None:
         self._controller.sendRawCommand(self, command)
 
     @pyqtProperty("QVariantList", constant = True)
-    def extruders(self):
+    def extruders(self) -> List["ExtruderOutputModel"]:
         return self._extruders
 
     @pyqtProperty(QVariant, notify = headPositionChanged)
-    def headPosition(self):
+    def headPosition(self) -> Dict[str, float]:
         return {"x": self._head_position.x, "y": self._head_position.y, "z": self.head_position.z}
 
-    def updateHeadPosition(self, x, y, z):
+    def updateHeadPosition(self, x: float, y: float, z: float) -> None:
         if self._head_position.x != x or self._head_position.y != y or self._head_position.z != z:
             self._head_position = Vector(x, y, z)
             self.headPositionChanged.emit()
 
     @pyqtProperty(float, float, float)
     @pyqtProperty(float, float, float, float)
-    def setHeadPosition(self, x, y, z, speed = 3000):
+    def setHeadPosition(self, x: float, y: float, z: float, speed: float = 3000) -> None:
         self.updateHeadPosition(x, y, z)
         self._controller.setHeadPosition(self, x, y, z, speed)
 
     @pyqtProperty(float)
     @pyqtProperty(float, float)
-    def setHeadX(self, x, speed = 3000):
+    def setHeadX(self, x: float, speed: float = 3000) -> None:
         self.updateHeadPosition(x, self._head_position.y, self._head_position.z)
         self._controller.setHeadPosition(self, x, self._head_position.y, self._head_position.z, speed)
 
     @pyqtProperty(float)
     @pyqtProperty(float, float)
-    def setHeadY(self, y, speed = 3000):
+    def setHeadY(self, y: float, speed: float = 3000) -> None:
         self.updateHeadPosition(self._head_position.x, y, self._head_position.z)
         self._controller.setHeadPosition(self, self._head_position.x, y, self._head_position.z, speed)
 
     @pyqtProperty(float)
     @pyqtProperty(float, float)
-    def setHeadZ(self, z, speed = 3000):
+    def setHeadZ(self, z: float, speed:float = 3000) -> None:
         self.updateHeadPosition(self._head_position.x, self._head_position.y, z)
         self._controller.setHeadPosition(self, self._head_position.x, self._head_position.y, z, speed)
 
     @pyqtSlot(float, float, float)
     @pyqtSlot(float, float, float, float)
-    def moveHead(self, x = 0, y = 0, z = 0, speed = 3000):
+    def moveHead(self, x: float = 0, y: float = 0, z: float = 0, speed: float = 3000) -> None:
         self._controller.moveHead(self, x, y, z, speed)
 
     ##  Pre-heats the heated bed of the printer.
@@ -162,47 +164,46 @@ class PrinterOutputModel(QObject):
     #   Celsius.
     #   \param duration How long the bed should stay warm, in seconds.
     @pyqtSlot(float, float)
-    def preheatBed(self, temperature, duration):
+    def preheatBed(self, temperature: float, duration: float) -> None:
         self._controller.preheatBed(self, temperature, duration)
 
     @pyqtSlot()
-    def cancelPreheatBed(self):
+    def cancelPreheatBed(self) -> None:
         self._controller.cancelPreheatBed(self)
 
-    def getController(self):
+    def getController(self) -> "PrinterOutputController":
         return self._controller
 
-    @pyqtProperty(str, notify=nameChanged)
-    def name(self):
+    @pyqtProperty(str, notify = nameChanged)
+    def name(self) -> str:
         return self._name
 
-    def setName(self, name):
-        self._setName(name)
+    def setName(self, name: str) -> None:
         self.updateName(name)
 
-    def updateName(self, name):
+    def updateName(self, name: str) -> None:
         if self._name != name:
             self._name = name
             self.nameChanged.emit()
 
     ##  Update the bed temperature. This only changes it locally.
-    def updateBedTemperature(self, temperature):
+    def updateBedTemperature(self, temperature: float) -> None:
         if self._bed_temperature != temperature:
             self._bed_temperature = temperature
             self.bedTemperatureChanged.emit()
 
-    def updateTargetBedTemperature(self, temperature):
+    def updateTargetBedTemperature(self, temperature: float) -> None:
         if self._target_bed_temperature != temperature:
             self._target_bed_temperature = temperature
             self.targetBedTemperatureChanged.emit()
 
     ##  Set the target bed temperature. This ensures that it's actually sent to the remote.
-    @pyqtSlot(int)
-    def setTargetBedTemperature(self, temperature):
+    @pyqtSlot(float)
+    def setTargetBedTemperature(self, temperature: float) -> None:
         self._controller.setTargetBedTemperature(self, temperature)
         self.updateTargetBedTemperature(temperature)
 
-    def updateActivePrintJob(self, print_job):
+    def updateActivePrintJob(self, print_job: Optional["PrintJobOutputModel"]) -> None:
         if self._active_print_job != print_job:
             old_print_job = self._active_print_job
 
@@ -214,76 +215,83 @@ class PrinterOutputModel(QObject):
                 old_print_job.updateAssignedPrinter(None)
             self.activePrintJobChanged.emit()
 
-    def updateState(self, printer_state):
+    def updateState(self, printer_state: str) -> None:
         if self._printer_state != printer_state:
             self._printer_state = printer_state
             self.stateChanged.emit()
 
     @pyqtProperty(QObject, notify = activePrintJobChanged)
-    def activePrintJob(self):
+    def activePrintJob(self) -> Optional["PrintJobOutputModel"]:
         return self._active_print_job
 
-    @pyqtProperty(str, notify=stateChanged)
-    def state(self):
+    @pyqtProperty(str, notify = stateChanged)
+    def state(self) -> str:
         return self._printer_state
 
-    @pyqtProperty(int, notify = bedTemperatureChanged)
-    def bedTemperature(self):
+    @pyqtProperty(float, notify = bedTemperatureChanged)
+    def bedTemperature(self) -> float:
         return self._bed_temperature
 
-    @pyqtProperty(int, notify=targetBedTemperatureChanged)
-    def targetBedTemperature(self):
+    @pyqtProperty(float, notify = targetBedTemperatureChanged)
+    def targetBedTemperature(self) -> float:
         return self._target_bed_temperature
 
     # Does the printer support pre-heating the bed at all
-    @pyqtProperty(bool, constant=True)
-    def canPreHeatBed(self):
+    @pyqtProperty(bool, constant = True)
+    def canPreHeatBed(self) -> bool:
         if self._controller:
             return self._controller.can_pre_heat_bed
         return False
 
     # Does the printer support pre-heating the bed at all
-    @pyqtProperty(bool, constant=True)
-    def canPreHeatHotends(self):
+    @pyqtProperty(bool, constant = True)
+    def canPreHeatHotends(self) -> bool:
         if self._controller:
             return self._controller.can_pre_heat_hotends
         return False
 
     # Does the printer support sending raw G-code at all
-    @pyqtProperty(bool, constant=True)
-    def canSendRawGcode(self):
+    @pyqtProperty(bool, constant = True)
+    def canSendRawGcode(self) -> bool:
         if self._controller:
             return self._controller.can_send_raw_gcode
         return False
 
     # Does the printer support pause at all
-    @pyqtProperty(bool, constant=True)
-    def canPause(self):
+    @pyqtProperty(bool, constant = True)
+    def canPause(self) -> bool:
         if self._controller:
             return self._controller.can_pause
         return False
 
     # Does the printer support abort at all
-    @pyqtProperty(bool, constant=True)
-    def canAbort(self):
+    @pyqtProperty(bool, constant = True)
+    def canAbort(self) -> bool:
         if self._controller:
             return self._controller.can_abort
         return False
 
     # Does the printer support manual control at all
-    @pyqtProperty(bool, constant=True)
-    def canControlManually(self):
+    @pyqtProperty(bool, constant = True)
+    def canControlManually(self) -> bool:
         if self._controller:
             return self._controller.can_control_manually
         return False
 
+    # Does the printer support upgrading firmware
+    @pyqtProperty(bool, notify = canUpdateFirmwareChanged)
+    def canUpdateFirmware(self) -> bool:
+        if self._controller:
+            return self._controller.can_update_firmware
+        return False
+
+    # Stub to connect UM.Signal to pyqtSignal
+    def _onControllerCanUpdateFirmwareChanged(self) -> None:
+        self.canUpdateFirmwareChanged.emit()
+
     # Returns the configuration (material, variant and buildplate) of the current printer
     @pyqtProperty(QObject, notify = configurationChanged)
-    def printerConfiguration(self):
+    def printerConfiguration(self) -> Optional[ConfigurationModel]:
         if self._printer_configuration.isValid():
             return self._printer_configuration
-        return None
-
-    def _updateExtruderConfiguration(self):
-        self._printer_configuration.extruderConfigurations = [extruder.extruderConfiguration for extruder in self._extruders]
-        self.configurationChanged.emit()
+        return None

cura/PrinterOutputDevice.py

@@ -1,36 +1,44 @@
 # Copyright (c) 2018 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
+from enum import IntEnum
+from typing import Callable, List, Optional, Union
 
 from UM.Decorators import deprecated
 from UM.i18n import i18nCatalog
 from UM.OutputDevice.OutputDevice import OutputDevice
-from PyQt5.QtCore import pyqtProperty, QObject, QTimer, pyqtSignal
+from PyQt5.QtCore import pyqtProperty, pyqtSignal, QObject, QTimer, QUrl
 from PyQt5.QtWidgets import QMessageBox
 
 from UM.Logger import Logger
-from UM.FileHandler.FileHandler import FileHandler #For typing.
-from UM.Scene.SceneNode import SceneNode #For typing.
 from UM.Signal import signalemitter
 from UM.Qt.QtApplication import QtApplication
-
-from enum import IntEnum  # For the connection state tracking.
-from typing import Callable, List, Optional
+from UM.FlameProfiler import pyqtSlot
 
 MYPY = False
 if MYPY:
     from cura.PrinterOutput.PrinterOutputModel import PrinterOutputModel
     from cura.PrinterOutput.ConfigurationModel import ConfigurationModel
+    from cura.PrinterOutput.FirmwareUpdater import FirmwareUpdater
+    from UM.FileHandler.FileHandler import FileHandler
+    from UM.Scene.SceneNode import SceneNode
 
 i18n_catalog = i18nCatalog("cura")
 
 
 ##  The current processing state of the backend.
 class ConnectionState(IntEnum):
-    closed = 0
-    connecting = 1
-    connected = 2
-    busy = 3
-    error = 4
+    Closed = 0
+    Connecting = 1
+    Connected = 2
+    Busy = 3
+    Error = 4
+
+
+class ConnectionType(IntEnum):
+    NotConnected = 0
+    UsbConnection = 1
+    NetworkConnection = 2
+    CloudConnection = 3
 
 
 ##  Printer output device adds extra interface options on top of output device.
@@ -44,6 +52,7 @@ class ConnectionState(IntEnum):
 #   For all other uses it should be used in the same way as a "regular" OutputDevice.
 @signalemitter
 class PrinterOutputDevice(QObject, OutputDevice):
+
     printersChanged = pyqtSignal()
     connectionStateChanged = pyqtSignal(str)
     acceptsCommandsChanged = pyqtSignal()
@@ -60,32 +69,34 @@ class PrinterOutputDevice(QObject, OutputDevice):
     # Signal to indicate that the configuration of one of the printers has changed.
     uniqueConfigurationsChanged = pyqtSignal()
 
-    def __init__(self, device_id: str, parent: QObject = None) -> None:
+    def __init__(self, device_id: str, connection_type: "ConnectionType" = ConnectionType.NotConnected, parent: QObject = None) -> None:
         super().__init__(device_id = device_id, parent = parent) # type: ignore  # MyPy complains with the multiple inheritance
 
         self._printers = []  # type: List[PrinterOutputModel]
         self._unique_configurations = []   # type: List[ConfigurationModel]
 
-        self._monitor_view_qml_path = "" #type: str
-        self._monitor_component = None #type: Optional[QObject]
-        self._monitor_item = None #type: Optional[QObject]
+        self._monitor_view_qml_path = ""  # type: str
+        self._monitor_component = None  # type: Optional[QObject]
+        self._monitor_item = None  # type: Optional[QObject]
 
-        self._control_view_qml_path = "" #type: str
-        self._control_component = None #type: Optional[QObject]
-        self._control_item = None #type: Optional[QObject]
+        self._control_view_qml_path = ""  # type: str
+        self._control_component = None  # type: Optional[QObject]
+        self._control_item = None  # type: Optional[QObject]
 
-        self._accepts_commands = False #type: bool
+        self._accepts_commands = False  # type: bool
 
-        self._update_timer = QTimer() #type: QTimer
+        self._update_timer = QTimer()  # type: QTimer
         self._update_timer.setInterval(2000)  # TODO; Add preference for update interval
         self._update_timer.setSingleShot(False)
         self._update_timer.timeout.connect(self._update)
 
-        self._connection_state = ConnectionState.closed #type: ConnectionState
+        self._connection_state = ConnectionState.Closed  # type: ConnectionState
+        self._connection_type = connection_type  # type: ConnectionType
 
-        self._firmware_name = None #type: Optional[str]
-        self._address = "" #type: str
-        self._connection_text = "" #type: str
+        self._firmware_updater = None  # type: Optional[FirmwareUpdater]
+        self._firmware_name = None  # type: Optional[str]
+        self._address = ""  # type: str
+        self._connection_text = ""  # type: str
         self.printersChanged.connect(self._onPrintersChanged)
         QtApplication.getInstance().getOutputDeviceManager().outputDevicesChanged.connect(self._updateUniqueConfigurations)
 
@@ -107,15 +118,19 @@ class PrinterOutputDevice(QObject, OutputDevice):
         callback(QMessageBox.Yes)
 
     def isConnected(self) -> bool:
-        return self._connection_state != ConnectionState.closed and self._connection_state != ConnectionState.error
+        return self._connection_state != ConnectionState.Closed and self._connection_state != ConnectionState.Error
 
-    def setConnectionState(self, connection_state: ConnectionState) -> None:
+    def setConnectionState(self, connection_state: "ConnectionState") -> None:
         if self._connection_state != connection_state:
             self._connection_state = connection_state
             self.connectionStateChanged.emit(self._id)
 
-    @pyqtProperty(str, notify = connectionStateChanged)
-    def connectionState(self) -> ConnectionState:
+    @pyqtProperty(int, constant = True)
+    def connectionType(self) -> "ConnectionType":
+        return self._connection_type
+
+    @pyqtProperty(int, notify = connectionStateChanged)
+    def connectionState(self) -> "ConnectionState":
         return self._connection_state
 
     def _update(self) -> None:
@@ -128,7 +143,8 @@ class PrinterOutputDevice(QObject, OutputDevice):
 
         return None
 
-    def requestWrite(self, nodes: List[SceneNode], file_name: Optional[str] = None, limit_mimetypes: bool = False, file_handler: Optional[FileHandler] = None, **kwargs: str) -> None:
+    def requestWrite(self, nodes: List["SceneNode"], file_name: Optional[str] = None, limit_mimetypes: bool = False,
+                     file_handler: Optional["FileHandler"] = None, **kwargs: str) -> None:
         raise NotImplementedError("requestWrite needs to be implemented")
 
     @pyqtProperty(QObject, notify = printersChanged)
@@ -171,13 +187,13 @@ class PrinterOutputDevice(QObject, OutputDevice):
 
     ##  Attempt to establish connection
     def connect(self) -> None:
-        self.setConnectionState(ConnectionState.connecting)
+        self.setConnectionState(ConnectionState.Connecting)
         self._update_timer.start()
 
     ##  Attempt to close the connection
     def close(self) -> None:
         self._update_timer.stop()
-        self.setConnectionState(ConnectionState.closed)
+        self.setConnectionState(ConnectionState.Closed)
 
     ##  Ensure that close gets called when object is destroyed
     def __del__(self) -> None:
@@ -204,10 +220,17 @@ class PrinterOutputDevice(QObject, OutputDevice):
         return self._unique_configurations
 
     def _updateUniqueConfigurations(self) -> None:
-        self._unique_configurations = list(set([printer.printerConfiguration for printer in self._printers if printer.printerConfiguration is not None]))
-        self._unique_configurations.sort(key = lambda k: k.printerType)
+        self._unique_configurations = sorted(
+            {printer.printerConfiguration for printer in self._printers if printer.printerConfiguration is not None},
+            key=lambda config: config.printerType,
+        )
         self.uniqueConfigurationsChanged.emit()
 
+    # Returns the unique configurations of the printers within this output device
+    @pyqtProperty("QStringList", notify = uniqueConfigurationsChanged)
+    def uniquePrinterTypes(self) -> List[str]:
+        return list(sorted(set([configuration.printerType for configuration in self._unique_configurations])))
+
     def _onPrintersChanged(self) -> None:
         for printer in self._printers:
             printer.configurationChanged.connect(self._updateUniqueConfigurations)
@@ -225,4 +248,14 @@ class PrinterOutputDevice(QObject, OutputDevice):
     #
     #   This name can be used to define device type
     def getFirmwareName(self) -> Optional[str]:
-        return self._firmware_name
+        return self._firmware_name
+
+    def getFirmwareUpdater(self) -> Optional["FirmwareUpdater"]:
+        return self._firmware_updater
+
+    @pyqtSlot(str)
+    def updateFirmware(self, firmware_file: Union[str, QUrl]) -> None:
+        if not self._firmware_updater:
+            return
+
+        self._firmware_updater.updateFirmware(firmware_file)

cura/Scene/BlockSlicingDecorator.py

@@ -1,9 +1,12 @@
+# Copyright (c) 2018 Ultimaker B.V.
+# Cura is released under the terms of the LGPLv3 or higher.
+
 from UM.Scene.SceneNodeDecorator import SceneNodeDecorator
 
 
 class BlockSlicingDecorator(SceneNodeDecorator):
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__()
 
-    def isBlockSlicing(self):
+    def isBlockSlicing(self) -> bool:
         return True

cura/Scene/ConvexHullDecorator.py

@@ -5,6 +5,7 @@ from PyQt5.QtCore import QTimer
 
 from UM.Application import Application
 from UM.Math.Polygon import Polygon
+
 from UM.Scene.SceneNodeDecorator import SceneNodeDecorator
 from UM.Settings.ContainerRegistry import ContainerRegistry
 
@@ -13,39 +14,49 @@ from cura.Scene import ConvexHullNode
 
 import numpy
 
+from typing import TYPE_CHECKING, Any, Optional
+
+if TYPE_CHECKING:
+    from UM.Scene.SceneNode import SceneNode
+    from cura.Settings.GlobalStack import GlobalStack
+    from UM.Mesh.MeshData import MeshData
+    from UM.Math.Matrix import Matrix
+
+
 ##  The convex hull decorator is a scene node decorator that adds the convex hull functionality to a scene node.
 #   If a scene node has a convex hull decorator, it will have a shadow in which other objects can not be printed.
 class ConvexHullDecorator(SceneNodeDecorator):
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__()
 
-        self._convex_hull_node = None
+        self._convex_hull_node = None  # type: Optional["SceneNode"]
         self._init2DConvexHullCache()
 
-        self._global_stack = None
+        self._global_stack = None  # type: Optional[GlobalStack]
 
         # Make sure the timer is created on the main thread
-        self._recompute_convex_hull_timer = None
-        Application.getInstance().callLater(self.createRecomputeConvexHullTimer)
+        self._recompute_convex_hull_timer = None  # type: Optional[QTimer]
+        from cura.CuraApplication import CuraApplication
+        if CuraApplication.getInstance() is not None:
+            CuraApplication.getInstance().callLater(self.createRecomputeConvexHullTimer)
 
         self._raft_thickness = 0.0
-        # For raft thickness, DRY
-        self._build_volume = Application.getInstance().getBuildVolume()
+        self._build_volume = CuraApplication.getInstance().getBuildVolume()
         self._build_volume.raftThicknessChanged.connect(self._onChanged)
 
-        Application.getInstance().globalContainerStackChanged.connect(self._onGlobalStackChanged)
-        Application.getInstance().getController().toolOperationStarted.connect(self._onChanged)
-        Application.getInstance().getController().toolOperationStopped.connect(self._onChanged)
+        CuraApplication.getInstance().globalContainerStackChanged.connect(self._onGlobalStackChanged)
+        CuraApplication.getInstance().getController().toolOperationStarted.connect(self._onChanged)
+        CuraApplication.getInstance().getController().toolOperationStopped.connect(self._onChanged)
 
         self._onGlobalStackChanged()
 
-    def createRecomputeConvexHullTimer(self):
+    def createRecomputeConvexHullTimer(self) -> None:
         self._recompute_convex_hull_timer = QTimer()
         self._recompute_convex_hull_timer.setInterval(200)
         self._recompute_convex_hull_timer.setSingleShot(True)
         self._recompute_convex_hull_timer.timeout.connect(self.recomputeConvexHull)
 
-    def setNode(self, node):
+    def setNode(self, node: "SceneNode") -> None:
         previous_node = self._node
         # Disconnect from previous node signals
         if previous_node is not None and node is not previous_node:
@@ -53,9 +64,9 @@ class ConvexHullDecorator(SceneNodeDecorator):
             previous_node.parentChanged.disconnect(self._onChanged)
 
         super().setNode(node)
-
-        self._node.transformationChanged.connect(self._onChanged)
-        self._node.parentChanged.connect(self._onChanged)
+        # Mypy doesn't understand that self._node is no longer optional, so just use the node.
+        node.transformationChanged.connect(self._onChanged)
+        node.parentChanged.connect(self._onChanged)
 
         self._onChanged()
 
@@ -63,37 +74,46 @@ class ConvexHullDecorator(SceneNodeDecorator):
     def __deepcopy__(self, memo):
         return ConvexHullDecorator()
 
-    ##  Get the unmodified 2D projected convex hull of the node
-    def getConvexHull(self):
+    ##  Get the unmodified 2D projected convex hull of the node (if any)
+    def getConvexHull(self) -> Optional[Polygon]:
         if self._node is None:
             return None
 
         hull = self._compute2DConvexHull()
 
-        if self._global_stack and self._node:
+        if self._global_stack and self._node is not None and hull is not None:
             # Parent can be None if node is just loaded.
-            if self._global_stack.getProperty("print_sequence", "value") == "one_at_a_time" and (self._node.getParent() is None or not self._node.getParent().callDecoration("isGroup")):
+            if self._global_stack.getProperty("print_sequence", "value") == "one_at_a_time" and not self.hasGroupAsParent(self._node):
                 hull = hull.getMinkowskiHull(Polygon(numpy.array(self._global_stack.getProperty("machine_head_polygon", "value"), numpy.float32)))
                 hull = self._add2DAdhesionMargin(hull)
         return hull
 
     ##  Get the convex hull of the node with the full head size
-    def getConvexHullHeadFull(self):
+    def getConvexHullHeadFull(self) -> Optional[Polygon]:
         if self._node is None:
             return None
 
         return self._compute2DConvexHeadFull()
 
+    @staticmethod
+    def hasGroupAsParent(node: "SceneNode") -> bool:
+        parent = node.getParent()
+        if parent is None:
+            return False
+        return bool(parent.callDecoration("isGroup"))
+
     ##  Get convex hull of the object + head size
     #   In case of printing all at once this is the same as the convex hull.
     #   For one at the time this is area with intersection of mirrored head
-    def getConvexHullHead(self):
+    def getConvexHullHead(self) -> Optional[Polygon]:
         if self._node is None:
             return None
 
         if self._global_stack:
-            if self._global_stack.getProperty("print_sequence", "value") == "one_at_a_time" and (self._node.getParent() is None or not self._node.getParent().callDecoration("isGroup")):
+            if self._global_stack.getProperty("print_sequence", "value") == "one_at_a_time" and not self.hasGroupAsParent(self._node):
                 head_with_fans = self._compute2DConvexHeadMin()
+                if head_with_fans is None:
+                    return None
                 head_with_fans_with_adhesion_margin = self._add2DAdhesionMargin(head_with_fans)
                 return head_with_fans_with_adhesion_margin
         return None
@@ -101,26 +121,33 @@ class ConvexHullDecorator(SceneNodeDecorator):
     ##  Get convex hull of the node
     #   In case of printing all at once this is the same as the convex hull.
     #   For one at the time this is the area without the head.
-    def getConvexHullBoundary(self):
+    def getConvexHullBoundary(self) -> Optional[Polygon]:
         if self._node is None:
             return None
 
         if self._global_stack:
-            if self._global_stack.getProperty("print_sequence", "value") == "one_at_a_time" and (self._node.getParent() is None or not self._node.getParent().callDecoration("isGroup")):
+            if self._global_stack.getProperty("print_sequence", "value") == "one_at_a_time" and not self.hasGroupAsParent(self._node):
                 # Printing one at a time and it's not an object in a group
                 return self._compute2DConvexHull()
         return None
 
-    def recomputeConvexHullDelayed(self):
+    ##  The same as recomputeConvexHull, but using a timer if it was set.
+    def recomputeConvexHullDelayed(self) -> None:
         if self._recompute_convex_hull_timer is not None:
             self._recompute_convex_hull_timer.start()
         else:
             self.recomputeConvexHull()
 
-    def recomputeConvexHull(self):
+    def recomputeConvexHull(self) -> None:
         controller = Application.getInstance().getController()
         root = controller.getScene().getRoot()
         if self._node is None or controller.isToolOperationActive() or not self.__isDescendant(root, self._node):
+            # If the tool operation is still active, we need to compute the convex hull later after the controller is
+            # no longer active.
+            if controller.isToolOperationActive():
+                self.recomputeConvexHullDelayed()
+                return
+
             if self._convex_hull_node:
                 self._convex_hull_node.setParent(None)
                 self._convex_hull_node = None
@@ -132,33 +159,38 @@ class ConvexHullDecorator(SceneNodeDecorator):
         hull_node = ConvexHullNode.ConvexHullNode(self._node, convex_hull, self._raft_thickness, root)
         self._convex_hull_node = hull_node
 
-    def _onSettingValueChanged(self, key, property_name):
-        if property_name != "value": #Not the value that was changed.
+    def _onSettingValueChanged(self, key: str, property_name: str) -> None:
+        if property_name != "value":  # Not the value that was changed.
             return
 
         if key in self._affected_settings:
             self._onChanged()
         if key in self._influencing_settings:
-            self._init2DConvexHullCache() #Invalidate the cache.
+            self._init2DConvexHullCache()  # Invalidate the cache.
             self._onChanged()
 
-    def _init2DConvexHullCache(self):
+    def _init2DConvexHullCache(self) -> None:
         # Cache for the group code path in _compute2DConvexHull()
-        self._2d_convex_hull_group_child_polygon = None
-        self._2d_convex_hull_group_result = None
+        self._2d_convex_hull_group_child_polygon = None  # type: Optional[Polygon]
+        self._2d_convex_hull_group_result = None  # type: Optional[Polygon]
 
         # Cache for the mesh code path in _compute2DConvexHull()
-        self._2d_convex_hull_mesh = None
-        self._2d_convex_hull_mesh_world_transform = None
-        self._2d_convex_hull_mesh_result = None
+        self._2d_convex_hull_mesh = None  # type: Optional[MeshData]
+        self._2d_convex_hull_mesh_world_transform = None  # type: Optional[Matrix]
+        self._2d_convex_hull_mesh_result = None  # type: Optional[Polygon]
 
-    def _compute2DConvexHull(self):
+    def _compute2DConvexHull(self) -> Optional[Polygon]:
+        if self._node is None:
+            return None
         if self._node.callDecoration("isGroup"):
             points = numpy.zeros((0, 2), dtype=numpy.int32)
             for child in self._node.getChildren():
                 child_hull = child.callDecoration("_compute2DConvexHull")
                 if child_hull:
-                    points = numpy.append(points, child_hull.getPoints(), axis = 0)
+                    try:
+                        points = numpy.append(points, child_hull.getPoints(), axis = 0)
+                    except ValueError:
+                        pass
 
                 if points.size < 3:
                     return None
@@ -178,49 +210,47 @@ class ConvexHullDecorator(SceneNodeDecorator):
             return offset_hull
 
         else:
-            offset_hull = None
-            mesh = None
-            world_transform = None
-            if self._node.getMeshData():
-                mesh = self._node.getMeshData()
-                world_transform = self._node.getWorldTransformation()
-
-                # Check the cache
-                if mesh is self._2d_convex_hull_mesh and world_transform == self._2d_convex_hull_mesh_world_transform:
-                    return self._2d_convex_hull_mesh_result
-
-                vertex_data = mesh.getConvexHullTransformedVertices(world_transform)
-                # Don't use data below 0.
-                # TODO; We need a better check for this as this gives poor results for meshes with long edges.
-                # Do not throw away vertices: the convex hull may be too small and objects can collide.
-                # vertex_data = vertex_data[vertex_data[:,1] >= -0.01]
-
-                if len(vertex_data) >= 4:
-                    # Round the vertex data to 1/10th of a mm, then remove all duplicate vertices
-                    # This is done to greatly speed up further convex hull calculations as the convex hull
-                    # becomes much less complex when dealing with highly detailed models.
-                    vertex_data = numpy.round(vertex_data, 1)
-
-                    vertex_data = vertex_data[:, [0, 2]]  # Drop the Y components to project to 2D.
-
-                    # Grab the set of unique points.
-                    #
-                    # This basically finds the unique rows in the array by treating them as opaque groups of bytes
-                    # which are as long as the 2 float64s in each row, and giving this view to numpy.unique() to munch.
-                    # See http://stackoverflow.com/questions/16970982/find-unique-rows-in-numpy-array
-                    vertex_byte_view = numpy.ascontiguousarray(vertex_data).view(
-                        numpy.dtype((numpy.void, vertex_data.dtype.itemsize * vertex_data.shape[1])))
-                    _, idx = numpy.unique(vertex_byte_view, return_index=True)
-                    vertex_data = vertex_data[idx]  # Select the unique rows by index.
-
-                    hull = Polygon(vertex_data)
-
-                    if len(vertex_data) >= 3:
-                        convex_hull = hull.getConvexHull()
-                        offset_hull = self._offsetHull(convex_hull)
-            else:
+            offset_hull = Polygon([])
+            mesh = self._node.getMeshData()
+            if mesh is None:
                 return Polygon([])  # Node has no mesh data, so just return an empty Polygon.
 
+            world_transform = self._node.getWorldTransformation()
+
+            # Check the cache
+            if mesh is self._2d_convex_hull_mesh and world_transform == self._2d_convex_hull_mesh_world_transform:
+                return self._2d_convex_hull_mesh_result
+
+            vertex_data = mesh.getConvexHullTransformedVertices(world_transform)
+            # Don't use data below 0.
+            # TODO; We need a better check for this as this gives poor results for meshes with long edges.
+            # Do not throw away vertices: the convex hull may be too small and objects can collide.
+            # vertex_data = vertex_data[vertex_data[:,1] >= -0.01]
+
+            if len(vertex_data) >= 4:  # type: ignore # mypy and numpy don't play along well just yet.
+                # Round the vertex data to 1/10th of a mm, then remove all duplicate vertices
+                # This is done to greatly speed up further convex hull calculations as the convex hull
+                # becomes much less complex when dealing with highly detailed models.
+                vertex_data = numpy.round(vertex_data, 1)
+
+                vertex_data = vertex_data[:, [0, 2]]  # Drop the Y components to project to 2D.
+
+                # Grab the set of unique points.
+                #
+                # This basically finds the unique rows in the array by treating them as opaque groups of bytes
+                # which are as long as the 2 float64s in each row, and giving this view to numpy.unique() to munch.
+                # See http://stackoverflow.com/questions/16970982/find-unique-rows-in-numpy-array
+                vertex_byte_view = numpy.ascontiguousarray(vertex_data).view(
+                    numpy.dtype((numpy.void, vertex_data.dtype.itemsize * vertex_data.shape[1])))
+                _, idx = numpy.unique(vertex_byte_view, return_index = True)
+                vertex_data = vertex_data[idx]  # Select the unique rows by index.
+
+                hull = Polygon(vertex_data)
+
+                if len(vertex_data) >= 3:
+                    convex_hull = hull.getConvexHull()
+                    offset_hull = self._offsetHull(convex_hull)
+
             # Store the result in the cache
             self._2d_convex_hull_mesh = mesh
             self._2d_convex_hull_mesh_world_transform = world_transform
@@ -228,42 +258,56 @@ class ConvexHullDecorator(SceneNodeDecorator):
 
             return offset_hull
 
-    def _getHeadAndFans(self):
-        return Polygon(numpy.array(self._global_stack.getHeadAndFansCoordinates(), numpy.float32))
+    def _getHeadAndFans(self) -> Polygon:
+        if self._global_stack:
+            return Polygon(numpy.array(self._global_stack.getHeadAndFansCoordinates(), numpy.float32))
+        return Polygon()
 
-    def _compute2DConvexHeadFull(self):
-        return self._compute2DConvexHull().getMinkowskiHull(self._getHeadAndFans())
+    def _compute2DConvexHeadFull(self) -> Optional[Polygon]:
+        convex_hull = self._compute2DConvexHull()
+        if convex_hull:
+            return convex_hull.getMinkowskiHull(self._getHeadAndFans())
+        return None
 
-    def _compute2DConvexHeadMin(self):
-        headAndFans = self._getHeadAndFans()
-        mirrored = headAndFans.mirror([0, 0], [0, 1]).mirror([0, 0], [1, 0])  # Mirror horizontally & vertically.
+    def _compute2DConvexHeadMin(self) -> Optional[Polygon]:
+        head_and_fans = self._getHeadAndFans()
+        mirrored = head_and_fans.mirror([0, 0], [0, 1]).mirror([0, 0], [1, 0])  # Mirror horizontally & vertically.
         head_and_fans = self._getHeadAndFans().intersectionConvexHulls(mirrored)
 
         # Min head hull is used for the push free
-        min_head_hull = self._compute2DConvexHull().getMinkowskiHull(head_and_fans)
-        return min_head_hull
+        convex_hull = self._compute2DConvexHull()
+        if convex_hull:
+            return convex_hull.getMinkowskiHull(head_and_fans)
+        return None
 
     ##  Compensate given 2D polygon with adhesion margin
     #   \return 2D polygon with added margin
-    def _add2DAdhesionMargin(self, poly):
+    def _add2DAdhesionMargin(self, poly: Polygon) -> Polygon:
+        if not self._global_stack:
+            return Polygon()
         # Compensate for raft/skirt/brim
         # Add extra margin depending on adhesion type
         adhesion_type = self._global_stack.getProperty("adhesion_type", "value")
 
+        max_length_available = 0.5 * min(
+            self._getSettingProperty("machine_width", "value"),
+            self._getSettingProperty("machine_depth", "value")
+        )
+
         if adhesion_type == "raft":
-            extra_margin = max(0, self._getSettingProperty("raft_margin", "value"))
+            extra_margin = min(max_length_available, max(0, self._getSettingProperty("raft_margin", "value")))
         elif adhesion_type == "brim":
-            extra_margin = max(0, self._getSettingProperty("brim_line_count", "value") * self._getSettingProperty("skirt_brim_line_width", "value"))
+            extra_margin = min(max_length_available, max(0, self._getSettingProperty("brim_line_count", "value") * self._getSettingProperty("skirt_brim_line_width", "value")))
         elif adhesion_type == "none":
             extra_margin = 0
         elif adhesion_type == "skirt":
-            extra_margin = max(
+            extra_margin = min(max_length_available, max(
                 0, self._getSettingProperty("skirt_gap", "value") +
-                   self._getSettingProperty("skirt_line_count", "value") * self._getSettingProperty("skirt_brim_line_width", "value"))
+                   self._getSettingProperty("skirt_line_count", "value") * self._getSettingProperty("skirt_brim_line_width", "value")))
         else:
             raise Exception("Unknown bed adhesion type. Did you forget to update the convex hull calculations for your new bed adhesion type?")
 
-        # adjust head_and_fans with extra margin
+        # Adjust head_and_fans with extra margin
         if extra_margin > 0:
             extra_margin_polygon = Polygon.approximatedCircle(extra_margin)
             poly = poly.getMinkowskiHull(extra_margin_polygon)
@@ -274,7 +318,7 @@ class ConvexHullDecorator(SceneNodeDecorator):
     #   \param convex_hull Polygon of the original convex hull.
     #   \return New Polygon instance that is offset with everything that
     #   influences the collision area.
-    def _offsetHull(self, convex_hull):
+    def _offsetHull(self, convex_hull: Polygon) -> Polygon:
         horizontal_expansion = max(
             self._getSettingProperty("xy_offset", "value"),
             self._getSettingProperty("xy_offset_layer_0", "value")
@@ -295,16 +339,16 @@ class ConvexHullDecorator(SceneNodeDecorator):
         else:
             return convex_hull
 
-    def _onChanged(self, *args):
+    def _onChanged(self, *args) -> None:
         self._raft_thickness = self._build_volume.getRaftThickness()
         if not args or args[0] == self._node:
             self.recomputeConvexHullDelayed()
 
-    def _onGlobalStackChanged(self):
+    def _onGlobalStackChanged(self) -> None:
         if self._global_stack:
             self._global_stack.propertyChanged.disconnect(self._onSettingValueChanged)
             self._global_stack.containersChanged.disconnect(self._onChanged)
-            extruders = ExtruderManager.getInstance().getMachineExtruders(self._global_stack.getId())
+            extruders = ExtruderManager.getInstance().getActiveExtruderStacks()
             for extruder in extruders:
                 extruder.propertyChanged.disconnect(self._onSettingValueChanged)
 
@@ -314,14 +358,16 @@ class ConvexHullDecorator(SceneNodeDecorator):
             self._global_stack.propertyChanged.connect(self._onSettingValueChanged)
             self._global_stack.containersChanged.connect(self._onChanged)
 
-            extruders = ExtruderManager.getInstance().getMachineExtruders(self._global_stack.getId())
+            extruders = ExtruderManager.getInstance().getActiveExtruderStacks()
             for extruder in extruders:
                 extruder.propertyChanged.connect(self._onSettingValueChanged)
 
             self._onChanged()
 
     ##   Private convenience function to get a setting from the correct extruder (as defined by limit_to_extruder property).
-    def _getSettingProperty(self, setting_key, prop = "value"):
+    def _getSettingProperty(self, setting_key: str, prop: str = "value") -> Any:
+        if self._global_stack is None or self._node is None:
+            return None
         per_mesh_stack = self._node.callDecoration("getStack")
         if per_mesh_stack:
             return per_mesh_stack.getProperty(setting_key, prop)
@@ -339,8 +385,8 @@ class ConvexHullDecorator(SceneNodeDecorator):
             # Limit_to_extruder is set. The global stack handles this then
             return self._global_stack.getProperty(setting_key, prop)
 
-    ## Returns true if node is a descendant or the same as the root node.
-    def __isDescendant(self, root, node):
+    ##  Returns True if node is a descendant or the same as the root node.
+    def __isDescendant(self, root: "SceneNode", node: Optional["SceneNode"]) -> bool:
         if node is None:
             return False
         if root is node:

cura/Scene/ConvexHullNode.py

@@ -1,7 +1,10 @@
 # Copyright (c) 2015 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
+from typing import Optional
 
 from UM.Application import Application
+from UM.Math.Polygon import Polygon
+from UM.Qt.QtApplication import QtApplication
 from UM.Scene.SceneNode import SceneNode
 from UM.Resources import Resources
 from UM.Math.Color import Color
@@ -16,7 +19,7 @@ class ConvexHullNode(SceneNode):
     #   location an object uses on the buildplate. This area (or area's in case of one at a time printing) is
     #   then displayed as a transparent shadow. If the adhesion type is set to raft, the area is extruded
     #   to represent the raft as well.
-    def __init__(self, node, hull, thickness, parent = None):
+    def __init__(self, node: SceneNode, hull: Optional[Polygon], thickness: float, parent: Optional[SceneNode] = None) -> None:
         super().__init__(parent)
 
         self.setCalculateBoundingBox(False)
@@ -25,7 +28,11 @@ class ConvexHullNode(SceneNode):
 
         # Color of the drawn convex hull
         if not Application.getInstance().getIsHeadLess():
-            self._color = Color(*Application.getInstance().getTheme().getColor("convex_hull").getRgb())
+            theme = QtApplication.getInstance().getTheme()
+            if theme:
+                self._color = Color(*theme.getColor("convex_hull").getRgb())
+            else:
+                self._color = Color(0, 0, 0)
         else:
             self._color = Color(0, 0, 0)
 
@@ -47,7 +54,7 @@ class ConvexHullNode(SceneNode):
 
             if hull_mesh_builder.addConvexPolygonExtrusion(
                 self._hull.getPoints()[::-1],  # bottom layer is reversed
-                self._mesh_height-thickness, self._mesh_height, color=self._color):
+                self._mesh_height - thickness, self._mesh_height, color = self._color):
 
                 hull_mesh = hull_mesh_builder.build()
                 self.setMeshData(hull_mesh)
@@ -75,7 +82,7 @@ class ConvexHullNode(SceneNode):
 
         return True
 
-    def _onNodeDecoratorsChanged(self, node):
+    def _onNodeDecoratorsChanged(self, node: SceneNode) -> None:
         convex_hull_head = self._node.callDecoration("getConvexHullHead")
         if convex_hull_head:
             convex_hull_head_builder = MeshBuilder()

cura/Scene/CuraSceneController.py

@@ -3,6 +3,7 @@ from UM.Logger import Logger
 from PyQt5.QtCore import Qt, pyqtSlot, QObject
 from PyQt5.QtWidgets import QApplication
 
+from UM.Scene.Camera import Camera
 from cura.ObjectsModel import ObjectsModel
 from cura.Machines.Models.MultiBuildPlateModel import MultiBuildPlateModel
 
@@ -33,7 +34,7 @@ class CuraSceneController(QObject):
             source = args[0]
         else:
             source = None
-        if not isinstance(source, SceneNode):
+        if not isinstance(source, SceneNode) or isinstance(source, Camera):
             return
         max_build_plate = self._calcMaxBuildPlate()
         changed = False

cura/Scene/GCodeListDecorator.py

@@ -1,13 +1,19 @@
 from UM.Scene.SceneNodeDecorator import SceneNodeDecorator
+from typing import List
 
 
 class GCodeListDecorator(SceneNodeDecorator):
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__()
-        self._gcode_list = []
+        self._gcode_list = []  # type: List[str]
 
-    def getGCodeList(self):
+    def getGCodeList(self) -> List[str]:
         return self._gcode_list
 
-    def setGCodeList(self, list):
+    def setGCodeList(self, list: List[str]) -> None:
         self._gcode_list = list
+
+    def __deepcopy__(self, memo) -> "GCodeListDecorator":
+        copied_decorator = GCodeListDecorator()
+        copied_decorator.setGCodeList(self.getGCodeList())
+        return copied_decorator

cura/Scene/SliceableObjectDecorator.py

@@ -2,11 +2,11 @@ from UM.Scene.SceneNodeDecorator import SceneNodeDecorator
 
 
 class SliceableObjectDecorator(SceneNodeDecorator):
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__()
         
-    def isSliceable(self):
+    def isSliceable(self) -> bool:
         return True
 
-    def __deepcopy__(self, memo):
+    def __deepcopy__(self, memo) -> "SliceableObjectDecorator":
         return type(self)()

cura/Scene/ZOffsetDecorator.py

@@ -1,18 +1,19 @@
 from UM.Scene.SceneNodeDecorator import SceneNodeDecorator
 
+
 ##  A decorator that stores the amount an object has been moved below the platform.
 class ZOffsetDecorator(SceneNodeDecorator):
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__()
-        self._z_offset = 0
+        self._z_offset = 0.
 
-    def setZOffset(self, offset):
+    def setZOffset(self, offset: float) -> None:
         self._z_offset = offset
 
-    def getZOffset(self):
+    def getZOffset(self) -> float:
         return self._z_offset
 
-    def __deepcopy__(self, memo):
+    def __deepcopy__(self, memo) -> "ZOffsetDecorator":
         copied_decorator = ZOffsetDecorator()
         copied_decorator.setZOffset(self.getZOffset())
         return copied_decorator

cura/Settings/ContainerManager.py

@@ -4,12 +4,12 @@
 import os
 import urllib.parse
 import uuid
-from typing import Any
-from typing import Dict, Union, Optional
+from typing import Dict, Union, Any, TYPE_CHECKING, List
 
-from PyQt5.QtCore import QObject, QUrl, QVariant
+from PyQt5.QtCore import QObject, QUrl
 from PyQt5.QtWidgets import QMessageBox
 
+
 from UM.i18n import i18nCatalog
 from UM.FlameProfiler import pyqtSlot
 from UM.Logger import Logger
@@ -21,6 +21,18 @@ from UM.Settings.ContainerStack import ContainerStack
 from UM.Settings.DefinitionContainer import DefinitionContainer
 from UM.Settings.InstanceContainer import InstanceContainer
 
+
+if TYPE_CHECKING:
+    from cura.CuraApplication import CuraApplication
+    from cura.Machines.ContainerNode import ContainerNode
+    from cura.Machines.MaterialNode import MaterialNode
+    from cura.Machines.QualityChangesGroup import QualityChangesGroup
+    from UM.PluginRegistry import PluginRegistry
+    from cura.Settings.MachineManager import MachineManager
+    from cura.Machines.MaterialManager import MaterialManager
+    from cura.Machines.QualityManager import QualityManager
+    from cura.Settings.CuraContainerRegistry import CuraContainerRegistry
+
 catalog = i18nCatalog("cura")
 
 
@@ -31,20 +43,20 @@ catalog = i18nCatalog("cura")
 #   when a certain action happens. This can be done through this class.
 class ContainerManager(QObject):
 
-    def __init__(self, application):
+    def __init__(self, application: "CuraApplication") -> None:
         if ContainerManager.__instance is not None:
             raise RuntimeError("Try to create singleton '%s' more than once" % self.__class__.__name__)
         ContainerManager.__instance = self
 
         super().__init__(parent = application)
 
-        self._application = application
-        self._plugin_registry = self._application.getPluginRegistry()
-        self._container_registry = self._application.getContainerRegistry()
-        self._machine_manager = self._application.getMachineManager()
-        self._material_manager = self._application.getMaterialManager()
-        self._quality_manager = self._application.getQualityManager()
-        self._container_name_filters = {}   # type: Dict[str, Dict[str, Any]]
+        self._application = application # type: CuraApplication
+        self._plugin_registry = self._application.getPluginRegistry()  # type: PluginRegistry
+        self._container_registry = self._application.getContainerRegistry()  # type: CuraContainerRegistry
+        self._machine_manager = self._application.getMachineManager()  # type: MachineManager
+        self._material_manager = self._application.getMaterialManager()  # type: MaterialManager
+        self._quality_manager = self._application.getQualityManager()  # type: QualityManager
+        self._container_name_filters = {}  # type: Dict[str, Dict[str, Any]]
 
     @pyqtSlot(str, str, result=str)
     def getContainerMetaDataEntry(self, container_id: str, entry_names: str) -> str:
@@ -69,21 +81,23 @@ class ContainerManager(QObject):
     #   by using "/" as a separator. For example, to change an entry "foo" in a
     #   dictionary entry "bar", you can specify "bar/foo" as entry name.
     #
-    #   \param container_id \type{str} The ID of the container to change.
+    #   \param container_node \type{ContainerNode}
     #   \param entry_name \type{str} The name of the metadata entry to change.
     #   \param entry_value The new value of the entry.
     #
-    #   \return True if successful, False if not.
     #  TODO: This is ONLY used by MaterialView for material containers. Maybe refactor this.
     #  Update: In order for QML to use objects and sub objects, those (sub) objects must all be QObject. Is that what we want?
     @pyqtSlot("QVariant", str, str)
-    def setContainerMetaDataEntry(self, container_node, entry_name, entry_value):
-        root_material_id = container_node.metadata["base_file"]
+    def setContainerMetaDataEntry(self, container_node: "ContainerNode", entry_name: str, entry_value: str) -> bool:
+        root_material_id = container_node.getMetaDataEntry("base_file", "")
         if self._container_registry.isReadOnly(root_material_id):
             Logger.log("w", "Cannot set metadata of read-only container %s.", root_material_id)
             return False
 
         material_group = self._material_manager.getMaterialGroup(root_material_id)
+        if material_group is None:
+            Logger.log("w", "Unable to find material group for: %s.", root_material_id)
+            return False
 
         entries = entry_name.split("/")
         entry_name = entries.pop()
@@ -91,11 +105,11 @@ class ContainerManager(QObject):
         sub_item_changed = False
         if entries:
             root_name = entries.pop(0)
-            root = material_group.root_material_node.metadata.get(root_name)
+            root = material_group.root_material_node.getMetaDataEntry(root_name)
 
             item = root
             for _ in range(len(entries)):
-                item = item.get(entries.pop(0), { })
+                item = item.get(entries.pop(0), {})
 
             if item[entry_name] != entry_value:
                 sub_item_changed = True
@@ -109,9 +123,10 @@ class ContainerManager(QObject):
             container.setMetaDataEntry(entry_name, entry_value)
             if sub_item_changed: #If it was only a sub-item that has changed then the setMetaDataEntry won't correctly notice that something changed, and we must manually signal that the metadata changed.
                 container.metaDataChanged.emit(container)
+        return True
 
     @pyqtSlot(str, result = str)
-    def makeUniqueName(self, original_name):
+    def makeUniqueName(self, original_name: str) -> str:
         return self._container_registry.uniqueName(original_name)
 
     ##  Get a list of string that can be used as name filters for a Qt File Dialog
@@ -125,7 +140,7 @@ class ContainerManager(QObject):
     #
     #   \return A string list with name filters.
     @pyqtSlot(str, result = "QStringList")
-    def getContainerNameFilters(self, type_name):
+    def getContainerNameFilters(self, type_name: str) -> List[str]:
         if not self._container_name_filters:
             self._updateContainerNameFilters()
 
@@ -257,7 +272,7 @@ class ContainerManager(QObject):
     #
     #   \return \type{bool} True if successful, False if not.
     @pyqtSlot(result = bool)
-    def updateQualityChanges(self):
+    def updateQualityChanges(self) -> bool:
         global_stack = self._machine_manager.activeMachine
         if not global_stack:
             return False
@@ -313,10 +328,10 @@ class ContainerManager(QObject):
     #   \param material_id \type{str} the id of the material for which to get the linked materials.
     #   \return \type{list} a list of names of materials with the same GUID
     @pyqtSlot("QVariant", bool, result = "QStringList")
-    def getLinkedMaterials(self, material_node, exclude_self = False):
-        guid = material_node.metadata["GUID"]
+    def getLinkedMaterials(self, material_node: "MaterialNode", exclude_self: bool = False):
+        guid = material_node.getMetaDataEntry("GUID", "")
 
-        self_root_material_id = material_node.metadata["base_file"]
+        self_root_material_id = material_node.getMetaDataEntry("base_file")
         material_group_list = self._material_manager.getMaterialGroupListByGUID(guid)
 
         linked_material_names = []
@@ -324,15 +339,19 @@ class ContainerManager(QObject):
             for material_group in material_group_list:
                 if exclude_self and material_group.name == self_root_material_id:
                     continue
-                linked_material_names.append(material_group.root_material_node.metadata["name"])
+                linked_material_names.append(material_group.root_material_node.getMetaDataEntry("name", ""))
         return linked_material_names
 
     ##  Unlink a material from all other materials by creating a new GUID
     #   \param material_id \type{str} the id of the material to create a new GUID for.
     @pyqtSlot("QVariant")
-    def unlinkMaterial(self, material_node):
+    def unlinkMaterial(self, material_node: "MaterialNode") -> None:
         # Get the material group
-        material_group = self._material_manager.getMaterialGroup(material_node.metadata["base_file"])
+        material_group = self._material_manager.getMaterialGroup(material_node.getMetaDataEntry("base_file", ""))
+
+        if material_group is None:
+            Logger.log("w", "Unable to find material group for %s", material_node)
+            return
 
         # Generate a new GUID
         new_guid = str(uuid.uuid4())
@@ -344,7 +363,7 @@ class ContainerManager(QObject):
         if container is not None:
             container.setMetaDataEntry("GUID", new_guid)
 
-    def _performMerge(self, merge_into, merge, clear_settings = True):
+    def _performMerge(self, merge_into: InstanceContainer, merge: InstanceContainer, clear_settings: bool = True) -> None:
         if merge == merge_into:
             return
 
@@ -372,7 +391,8 @@ class ContainerManager(QObject):
                 continue
 
             mime_type = self._container_registry.getMimeTypeForContainer(container_type)
-
+            if mime_type is None:
+                continue
             entry = {
                 "type": serialize_type,
                 "mime": mime_type,
@@ -399,17 +419,17 @@ class ContainerManager(QObject):
             self._container_name_filters[name_filter] = entry
 
     ##  Import single profile, file_url does not have to end with curaprofile
-    @pyqtSlot(QUrl, result="QVariantMap")
-    def importProfile(self, file_url):
+    @pyqtSlot(QUrl, result = "QVariantMap")
+    def importProfile(self, file_url: QUrl) -> Dict[str, str]:
         if not file_url.isValid():
-            return
+            return {"status": "error", "message": catalog.i18nc("@info:status", "Invalid file URL:") + " " + str(file_url)}
         path = file_url.toLocalFile()
         if not path:
-            return
+            return {"status": "error", "message": catalog.i18nc("@info:status", "Invalid file URL:") + " " + str(file_url)}
         return self._container_registry.importProfile(path)
 
     @pyqtSlot(QObject, QUrl, str)
-    def exportQualityChangesGroup(self, quality_changes_group, file_url: QUrl, file_type: str):
+    def exportQualityChangesGroup(self, quality_changes_group: "QualityChangesGroup", file_url: QUrl, file_type: str) -> None:
         if not file_url.isValid():
             return
         path = file_url.toLocalFile()

cura/Settings/CuraContainerRegistry.py

@@ -5,12 +5,12 @@ import os
 import re
 import configparser
 
-from typing import cast, Optional
-
+from typing import cast, Dict, Optional
 from PyQt5.QtWidgets import QMessageBox
 
 from UM.Decorators import override
 from UM.Settings.ContainerFormatError import ContainerFormatError
+from UM.Settings.Interfaces import ContainerInterface
 from UM.Settings.ContainerRegistry import ContainerRegistry
 from UM.Settings.ContainerStack import ContainerStack
 from UM.Settings.InstanceContainer import InstanceContainer
@@ -28,7 +28,7 @@ from . import GlobalStack
 
 import cura.CuraApplication
 from cura.Machines.QualityManager import getMachineDefinitionIDForQualitySearch
-from cura.ReaderWriters.ProfileReader import NoProfileException
+from cura.ReaderWriters.ProfileReader import NoProfileException, ProfileReader
 
 from UM.i18n import i18nCatalog
 catalog = i18nCatalog("cura")
@@ -161,20 +161,20 @@ class CuraContainerRegistry(ContainerRegistry):
 
     ##  Imports a profile from a file
     #
-    #   \param file_name \type{str} the full path and filename of the profile to import
-    #   \return \type{Dict} dict with a 'status' key containing the string 'ok' or 'error', and a 'message' key
-    #       containing a message for the user
-    def importProfile(self, file_name):
+    #   \param file_name The full path and filename of the profile to import.
+    #   \return Dict with a 'status' key containing the string 'ok' or 'error',
+    #       and a 'message' key containing a message for the user.
+    def importProfile(self, file_name: str) -> Dict[str, str]:
         Logger.log("d", "Attempting to import profile %s", file_name)
         if not file_name:
-            return { "status": "error", "message": catalog.i18nc("@info:status Don't translate the XML tags <filename> or <message>!", "Failed to import profile from <filename>{0}</filename>: <message>{1}</message>", file_name, "Invalid path")}
+            return { "status": "error", "message": catalog.i18nc("@info:status Don't translate the XML tags <filename>!", "Failed to import profile from <filename>{0}</filename>: {1}", file_name, "Invalid path")}
 
         plugin_registry = PluginRegistry.getInstance()
         extension = file_name.split(".")[-1]
 
         global_stack = Application.getInstance().getGlobalContainerStack()
         if not global_stack:
-            return
+            return {"status": "error", "message": catalog.i18nc("@info:status Don't translate the XML tags <filename>!", "Can't import profile from <filename>{0}</filename> before a printer is added.", file_name)}
 
         machine_extruders = []
         for position in sorted(global_stack.extruders):
@@ -183,15 +183,15 @@ class CuraContainerRegistry(ContainerRegistry):
         for plugin_id, meta_data in self._getIOPlugins("profile_reader"):
             if meta_data["profile_reader"][0]["extension"] != extension:
                 continue
-            profile_reader = plugin_registry.getPluginObject(plugin_id)
+            profile_reader = cast(ProfileReader, plugin_registry.getPluginObject(plugin_id))
             try:
                 profile_or_list = profile_reader.read(file_name)  # Try to open the file with the profile reader.
             except NoProfileException:
-                return { "status": "ok", "message": catalog.i18nc("@info:status Don't translate the XML tags <filename> or <message>!", "No custom profile to import in file <filename>{0}</filename>", file_name)}
+                return { "status": "ok", "message": catalog.i18nc("@info:status Don't translate the XML tags <filename>!", "No custom profile to import in file <filename>{0}</filename>", file_name)}
             except Exception as e:
                 # Note that this will fail quickly. That is, if any profile reader throws an exception, it will stop reading. It will only continue reading if the reader returned None.
                 Logger.log("e", "Failed to import profile from %s: %s while using profile reader. Got exception %s", file_name, profile_reader.getPluginId(), str(e))
-                return { "status": "error", "message": catalog.i18nc("@info:status Don't translate the XML tags <filename> or <message>!", "Failed to import profile from <filename>{0}</filename>: <message>{1}</message>", file_name, "\n" + str(e))}
+                return { "status": "error", "message": catalog.i18nc("@info:status Don't translate the XML tags <filename>!", "Failed to import profile from <filename>{0}</filename>:", file_name) + "\n<message>" + str(e) + "</message>"}
 
             if profile_or_list:
                 # Ensure it is always a list of profiles
@@ -215,19 +215,19 @@ class CuraContainerRegistry(ContainerRegistry):
                 if not global_profile:
                     Logger.log("e", "Incorrect profile [%s]. Could not find global profile", file_name)
                     return { "status": "error",
-                             "message": catalog.i18nc("@info:status Don't translate the XML tags <filename> or <message>!", "This profile <filename>{0}</filename> contains incorrect data, could not import it.", file_name)}
+                             "message": catalog.i18nc("@info:status Don't translate the XML tags <filename>!", "This profile <filename>{0}</filename> contains incorrect data, could not import it.", file_name)}
                 profile_definition = global_profile.getMetaDataEntry("definition")
 
                 # Make sure we have a profile_definition in the file:
                 if profile_definition is None:
                     break
-                machine_definition = self.findDefinitionContainers(id = profile_definition)
-                if not machine_definition:
+                machine_definitions = self.findDefinitionContainers(id = profile_definition)
+                if not machine_definitions:
                     Logger.log("e", "Incorrect profile [%s]. Unknown machine type [%s]", file_name, profile_definition)
                     return {"status": "error",
-                            "message": catalog.i18nc("@info:status Don't translate the XML tags <filename> or <message>!", "This profile <filename>{0}</filename> contains incorrect data, could not import it.", file_name)
+                            "message": catalog.i18nc("@info:status Don't translate the XML tags <filename>!", "This profile <filename>{0}</filename> contains incorrect data, could not import it.", file_name)
                             }
-                machine_definition = machine_definition[0]
+                machine_definition = machine_definitions[0]
 
                 # Get the expected machine definition.
                 # i.e.: We expect gcode for a UM2 Extended to be defined as normal UM2 gcode...
@@ -238,7 +238,7 @@ class CuraContainerRegistry(ContainerRegistry):
                 if profile_definition != expected_machine_definition:
                     Logger.log("e", "Profile [%s] is for machine [%s] but the current active machine is [%s]. Will not import the profile", file_name, profile_definition, expected_machine_definition)
                     return { "status": "error",
-                             "message": catalog.i18nc("@info:status Don't translate the XML tags <filename> or <message>!", "The machine defined in profile <filename>{0}</filename> ({1}) doesn't match with your current machine ({2}), could not import it.", file_name, profile_definition, expected_machine_definition)}
+                             "message": catalog.i18nc("@info:status Don't translate the XML tags <filename>!", "The machine defined in profile <filename>{0}</filename> ({1}) doesn't match with your current machine ({2}), could not import it.", file_name, profile_definition, expected_machine_definition)}
 
                 # Fix the global quality profile's definition field in case it's not correct
                 global_profile.setMetaDataEntry("definition", expected_machine_definition)
@@ -267,19 +267,19 @@ class CuraContainerRegistry(ContainerRegistry):
                         profile.setMetaDataEntry("position", "0")
                         profile.setDirty(True)
                         if idx == 0:
-                            # move all per-extruder settings to the first extruder's quality_changes
+                            # Move all per-extruder settings to the first extruder's quality_changes
                             for qc_setting_key in global_profile.getAllKeys():
-                                settable_per_extruder = global_stack.getProperty(qc_setting_key,
-                                                                                           "settable_per_extruder")
+                                settable_per_extruder = global_stack.getProperty(qc_setting_key, "settable_per_extruder")
                                 if settable_per_extruder:
                                     setting_value = global_profile.getProperty(qc_setting_key, "value")
 
                                     setting_definition = global_stack.getSettingDefinition(qc_setting_key)
-                                    new_instance = SettingInstance(setting_definition, profile)
-                                    new_instance.setProperty("value", setting_value)
-                                    new_instance.resetState()  # Ensure that the state is not seen as a user state.
-                                    profile.addInstance(new_instance)
-                                    profile.setDirty(True)
+                                    if setting_definition is not None:
+                                        new_instance = SettingInstance(setting_definition, profile)
+                                        new_instance.setProperty("value", setting_value)
+                                        new_instance.resetState()  # Ensure that the state is not seen as a user state.
+                                        profile.addInstance(new_instance)
+                                        profile.setDirty(True)
 
                                     global_profile.removeInstance(qc_setting_key, postpone_emit=True)
                         extruder_profiles.append(profile)
@@ -291,7 +291,7 @@ class CuraContainerRegistry(ContainerRegistry):
                 for profile_index, profile in enumerate(profile_or_list):
                     if profile_index == 0:
                         # This is assumed to be the global profile
-                        profile_id = (global_stack.getBottom().getId() + "_" + name_seed).lower().replace(" ", "_")
+                        profile_id = (cast(ContainerInterface, global_stack.getBottom()).getId() + "_" + name_seed).lower().replace(" ", "_")
 
                     elif profile_index < len(machine_extruders) + 1:
                         # This is assumed to be an extruder profile
@@ -303,15 +303,15 @@ class CuraContainerRegistry(ContainerRegistry):
                             profile.setMetaDataEntry("position", extruder_position)
                         profile_id = (extruder_id + "_" + name_seed).lower().replace(" ", "_")
 
-                    else: #More extruders in the imported file than in the machine.
-                        continue #Delete the additional profiles.
+                    else:  # More extruders in the imported file than in the machine.
+                        continue  # Delete the additional profiles.
 
                     result = self._configureProfile(profile, profile_id, new_name, expected_machine_definition)
                     if result is not None:
                         return {"status": "error", "message": catalog.i18nc(
                             "@info:status Don't translate the XML tags <filename> or <message>!",
-                            "Failed to import profile from <filename>{0}</filename>: <message>{1}</message>",
-                            file_name, result)}
+                            "Failed to import profile from <filename>{0}</filename>:",
+                            file_name) + " <message>" + result + "</message>"}
 
                 return {"status": "ok", "message": catalog.i18nc("@info:status", "Successfully imported profile {0}", profile_or_list[0].getName())}
 
@@ -386,30 +386,6 @@ class CuraContainerRegistry(ContainerRegistry):
                 result.append( (plugin_id, meta_data) )
         return result
 
-    ##  Returns true if the current machine requires its own materials
-    #   \return True if the current machine requires its own materials
-    def _machineHasOwnMaterials(self):
-        global_container_stack = Application.getInstance().getGlobalContainerStack()
-        if global_container_stack:
-            return global_container_stack.getMetaDataEntry("has_materials", False)
-        return False
-
-    ##  Gets the ID of the active material
-    #   \return the ID of the active material or the empty string
-    def _activeMaterialId(self):
-        global_container_stack = Application.getInstance().getGlobalContainerStack()
-        if global_container_stack and global_container_stack.material:
-            return global_container_stack.material.getId()
-        return ""
-
-    ##  Returns true if the current machine requires its own quality profiles
-    #   \return true if the current machine requires its own quality profiles
-    def _machineHasOwnQualities(self):
-        global_container_stack = Application.getInstance().getGlobalContainerStack()
-        if global_container_stack:
-            return parseBool(global_container_stack.getMetaDataEntry("has_machine_quality", False))
-        return False
-
     ##  Convert an "old-style" pure ContainerStack to either an Extruder or Global stack.
     def _convertContainerStack(self, container):
         assert type(container) == ContainerStack
@@ -521,7 +497,7 @@ class CuraContainerRegistry(ContainerRegistry):
         user_container.setMetaDataEntry("position", extruder_stack.getMetaDataEntry("position"))
 
         if machine.userChanges:
-            # for the newly created extruder stack, we need to move all "per-extruder" settings to the user changes
+            # For the newly created extruder stack, we need to move all "per-extruder" settings to the user changes
             # container to the extruder stack.
             for user_setting_key in machine.userChanges.getAllKeys():
                 settable_per_extruder = machine.getProperty(user_setting_key, "settable_per_extruder")
@@ -583,7 +559,7 @@ class CuraContainerRegistry(ContainerRegistry):
                     extruder_quality_changes_container.setMetaDataEntry("position", extruder_definition.getMetaDataEntry("position"))
                     extruder_stack.qualityChanges = self.findInstanceContainers(id = quality_changes_id)[0]
                 else:
-                    # if we still cannot find a quality changes container for the extruder, create a new one
+                    # If we still cannot find a quality changes container for the extruder, create a new one
                     container_name = machine_quality_changes.getName()
                     container_id = self.uniqueName(extruder_stack.getId() + "_qc_" + container_name)
                     extruder_quality_changes_container = InstanceContainer(container_id, parent = application)
@@ -601,7 +577,7 @@ class CuraContainerRegistry(ContainerRegistry):
                 Logger.log("w", "Could not find quality_changes named [%s] for extruder [%s]",
                            machine_quality_changes.getName(), extruder_stack.getId())
             else:
-                # move all per-extruder settings to the extruder's quality changes
+                # Move all per-extruder settings to the extruder's quality changes
                 for qc_setting_key in machine_quality_changes.getAllKeys():
                     settable_per_extruder = machine.getProperty(qc_setting_key, "settable_per_extruder")
                     if settable_per_extruder:
@@ -642,7 +618,7 @@ class CuraContainerRegistry(ContainerRegistry):
             if qc_name not in qc_groups:
                 qc_groups[qc_name] = []
             qc_groups[qc_name].append(qc)
-            # try to find from the quality changes cura directory too
+            # Try to find from the quality changes cura directory too
             quality_changes_container = self._findQualityChangesContainerInCuraFolder(machine_quality_changes.getName())
             if quality_changes_container:
                 qc_groups[qc_name].append(quality_changes_container)
@@ -656,7 +632,7 @@ class CuraContainerRegistry(ContainerRegistry):
                 else:
                     qc_dict["global"] = qc
             if qc_dict["global"] is not None and len(qc_dict["extruders"]) == 1:
-                # move per-extruder settings
+                # Move per-extruder settings
                 for qc_setting_key in qc_dict["global"].getAllKeys():
                     settable_per_extruder = machine.getProperty(qc_setting_key, "settable_per_extruder")
                     if settable_per_extruder:
@@ -686,21 +662,21 @@ class CuraContainerRegistry(ContainerRegistry):
             if not os.path.isfile(file_path):
                 continue
 
-            parser = configparser.ConfigParser(interpolation=None)
+            parser = configparser.ConfigParser(interpolation = None)
             try:
                 parser.read([file_path])
             except:
-                # skip, it is not a valid stack file
+                # Skip, it is not a valid stack file
                 continue
 
             if not parser.has_option("general", "name"):
                 continue
 
             if parser["general"]["name"] == name:
-                # load the container
+                # Load the container
                 container_id = os.path.basename(file_path).replace(".inst.cfg", "")
                 if self.findInstanceContainers(id = container_id):
-                    # this container is already in the registry, skip it
+                    # This container is already in the registry, skip it
                     continue
 
                 instance_container = InstanceContainer(container_id)
@@ -734,8 +710,8 @@ class CuraContainerRegistry(ContainerRegistry):
             else:
                 Logger.log("w", "Could not find machine {machine} for extruder {extruder}", machine = extruder_stack.getMetaDataEntry("machine"), extruder = extruder_stack.getId())
 
-    #Override just for the type.
+    # Override just for the type.
     @classmethod
     @override(ContainerRegistry)
     def getInstance(cls, *args, **kwargs) -> "CuraContainerRegistry":
-        return cast(CuraContainerRegistry, super().getInstance(*args, **kwargs))
+        return cast(CuraContainerRegistry, super().getInstance(*args, **kwargs))

cura/Settings/CuraContainerStack.py

@@ -145,13 +145,11 @@ class CuraContainerStack(ContainerStack):
     def setDefinition(self, new_definition: DefinitionContainerInterface) -> None:
         self.replaceContainer(_ContainerIndexes.Definition, new_definition)
 
-    ##  Get the definition container.
-    #
-    #   \return The definition container. Should always be a valid container, but can be equal to the empty InstanceContainer.
-    @pyqtProperty(QObject, fset = setDefinition, notify = pyqtContainersChanged)
-    def definition(self) -> DefinitionContainer:
+    def getDefinition(self) -> "DefinitionContainer":
         return cast(DefinitionContainer, self._containers[_ContainerIndexes.Definition])
 
+    definition = pyqtProperty(QObject, fget = getDefinition, fset = setDefinition, notify = pyqtContainersChanged)
+
     @override(ContainerStack)
     def getBottom(self) -> "DefinitionContainer":
         return self.definition
@@ -291,7 +289,7 @@ class CuraContainerStack(ContainerStack):
 
     # Helper to make sure we emit a PyQt signal on container changes.
     def _onContainersChanged(self, container: Any) -> None:
-        self.pyqtContainersChanged.emit()
+        Application.getInstance().callLater(self.pyqtContainersChanged.emit)
 
     # Helper that can be overridden to get the "machine" definition, that is, the definition that defines the machine
     # and its properties rather than, for example, the extruder. Defaults to simply returning the definition property.

cura/Settings/CuraFormulaFunctions.py

@@ -0,0 +1,135 @@
+# Copyright (c) 2018 Ultimaker B.V.
+# Cura is released under the terms of the LGPLv3 or higher.
+
+from typing import Any, List, Optional, TYPE_CHECKING
+
+from UM.Settings.PropertyEvaluationContext import PropertyEvaluationContext
+from UM.Settings.SettingFunction import SettingFunction
+from UM.Logger import Logger
+
+if TYPE_CHECKING:
+    from cura.CuraApplication import CuraApplication
+    from cura.Settings.CuraContainerStack import CuraContainerStack
+
+
+#
+# This class contains all Cura-related custom functions that can be used in formulas. Some functions requires
+# information such as the currently active machine, so this is made into a class instead of standalone functions.
+#
+class CuraFormulaFunctions:
+
+    def __init__(self, application: "CuraApplication") -> None:
+        self._application = application
+
+    # ================
+    # Custom Functions
+    # ================
+
+    # Gets the default extruder position of the currently active machine.
+    def getDefaultExtruderPosition(self) -> str:
+        machine_manager = self._application.getMachineManager()
+        return machine_manager.defaultExtruderPosition
+
+    # Gets the given setting key from the given extruder position.
+    def getValueInExtruder(self, extruder_position: int, property_key: str,
+                           context: Optional["PropertyEvaluationContext"] = None) -> Any:
+        machine_manager = self._application.getMachineManager()
+
+        if extruder_position == -1:
+            extruder_position = int(machine_manager.defaultExtruderPosition)
+
+        global_stack = machine_manager.activeMachine
+        try:
+            extruder_stack = global_stack.extruders[str(extruder_position)]
+        except KeyError:
+            Logger.log("w", "Value for %s of extruder %s was requested, but that extruder is not available" % (property_key, extruder_position))
+            return None
+
+        value = extruder_stack.getRawProperty(property_key, "value", context = context)
+        if isinstance(value, SettingFunction):
+            value = value(extruder_stack, context = context)
+
+        return value
+
+    # Gets all extruder values as a list for the given property.
+    def getValuesInAllExtruders(self, property_key: str,
+                                context: Optional["PropertyEvaluationContext"] = None) -> List[Any]:
+        machine_manager = self._application.getMachineManager()
+        extruder_manager = self._application.getExtruderManager()
+
+        global_stack = machine_manager.activeMachine
+
+        result = []
+        for extruder in extruder_manager.getActiveExtruderStacks():
+            if not extruder.isEnabled:
+                continue
+            # only include values from extruders that are "active" for the current machine instance
+            if int(extruder.getMetaDataEntry("position")) >= global_stack.getProperty("machine_extruder_count", "value", context = context):
+                continue
+
+            value = extruder.getRawProperty(property_key, "value", context = context)
+
+            if value is None:
+                continue
+
+            if isinstance(value, SettingFunction):
+                value = value(extruder, context = context)
+
+            result.append(value)
+
+        if not result:
+            result.append(global_stack.getProperty(property_key, "value", context = context))
+
+        return result
+
+    # Get the resolve value or value for a given key.
+    def getResolveOrValue(self, property_key: str, context: Optional["PropertyEvaluationContext"] = None) -> Any:
+        machine_manager = self._application.getMachineManager()
+
+        global_stack = machine_manager.activeMachine
+        resolved_value = global_stack.getProperty(property_key, "value", context = context)
+
+        return resolved_value
+
+    # Gets the default setting value from given extruder position. The default value is what excludes the values in
+    # the user_changes container.
+    def getDefaultValueInExtruder(self, extruder_position: int, property_key: str) -> Any:
+        machine_manager = self._application.getMachineManager()
+
+        global_stack = machine_manager.activeMachine
+        extruder_stack = global_stack.extruders[str(extruder_position)]
+
+        context = self.createContextForDefaultValueEvaluation(extruder_stack)
+
+        return self.getValueInExtruder(extruder_position, property_key, context = context)
+
+    # Gets all default setting values as a list from all extruders of the currently active machine.
+    # The default values are those excluding the values in the user_changes container.
+    def getDefaultValuesInAllExtruders(self, property_key: str) -> List[Any]:
+        machine_manager = self._application.getMachineManager()
+
+        global_stack = machine_manager.activeMachine
+
+        context = self.createContextForDefaultValueEvaluation(global_stack)
+
+        return self.getValuesInAllExtruders(property_key, context = context)
+
+    # Gets the resolve value or value for a given key without looking the first container (user container).
+    def getDefaultResolveOrValue(self, property_key: str) -> Any:
+        machine_manager = self._application.getMachineManager()
+
+        global_stack = machine_manager.activeMachine
+
+        context = self.createContextForDefaultValueEvaluation(global_stack)
+        return self.getResolveOrValue(property_key, context = context)
+
+    # Creates a context for evaluating default values (skip the user_changes container).
+    def createContextForDefaultValueEvaluation(self, source_stack: "CuraContainerStack") -> "PropertyEvaluationContext":
+        context = PropertyEvaluationContext(source_stack)
+        context.context["evaluate_from_container_index"] = 1  # skip the user settings container
+        context.context["override_operators"] = {
+            "extruderValue": self.getDefaultValueInExtruder,
+            "extruderValues": self.getDefaultValuesInAllExtruders,
+            "resolveOrValue": self.getDefaultResolveOrValue,
+        }
+        return context

cura/Settings/CuraStackBuilder.py

@@ -15,6 +15,7 @@ from .ExtruderStack import ExtruderStack
 
 ##  Contains helper functions to create new machines.
 class CuraStackBuilder:
+
     ##  Create a new instance of a machine.
     #
     #   \param name The name of the new machine.
@@ -26,7 +27,6 @@ class CuraStackBuilder:
         from cura.CuraApplication import CuraApplication
         application = CuraApplication.getInstance()
         variant_manager = application.getVariantManager()
-        material_manager = application.getMaterialManager()
         quality_manager = application.getQualityManager()
         registry = application.getContainerRegistry()
 
@@ -46,16 +46,6 @@ class CuraStackBuilder:
         if not global_variant_container:
             global_variant_container = application.empty_variant_container
 
-        # get variant container for extruders
-        extruder_variant_container = application.empty_variant_container
-        extruder_variant_node = variant_manager.getDefaultVariantNode(machine_definition, VariantType.NOZZLE)
-        extruder_variant_name = None
-        if extruder_variant_node:
-            extruder_variant_container = extruder_variant_node.getContainer()
-            if not extruder_variant_container:
-                extruder_variant_container = application.empty_variant_container
-            extruder_variant_name = extruder_variant_container.getName()
-
         generated_name = registry.createUniqueName("machine", "", name, machine_definition.getName())
         # Make sure the new name does not collide with any definition or (quality) profile
         # createUniqueName() only looks at other stacks, but not at definitions or quality profiles
@@ -74,34 +64,8 @@ class CuraStackBuilder:
 
         # Create ExtruderStacks
         extruder_dict = machine_definition.getMetaDataEntry("machine_extruder_trains")
-
-        for position, extruder_definition_id in extruder_dict.items():
-            # Sanity check: make sure that the positions in the extruder definitions are same as in the machine
-            # definition
-            extruder_definition = registry.findDefinitionContainers(id = extruder_definition_id)[0]
-            position_in_extruder_def = extruder_definition.getMetaDataEntry("position")
-            if position_in_extruder_def != position:
-                ConfigurationErrorMessage.getInstance().addFaultyContainers(extruder_definition_id)
-                return None #Don't return any container stack then, not the rest of the extruders either.
-
-            # get material container for extruders
-            material_container = application.empty_material_container
-            material_node = material_manager.getDefaultMaterial(new_global_stack, position, extruder_variant_name, extruder_definition = extruder_definition)
-            if material_node and material_node.getContainer():
-                material_container = material_node.getContainer()
-
-            new_extruder_id = registry.uniqueName(extruder_definition_id)
-            new_extruder = cls.createExtruderStack(
-                new_extruder_id,
-                extruder_definition = extruder_definition,
-                machine_definition_id = definition_id,
-                position = position,
-                variant_container = extruder_variant_container,
-                material_container = material_container,
-                quality_container = application.empty_quality_container
-            )
-            new_extruder.setNextStack(new_global_stack)
-            new_global_stack.addExtruder(new_extruder)
+        for position in extruder_dict:
+            cls.createExtruderStackWithDefaultSetup(new_global_stack, position)
 
         for new_extruder in new_global_stack.extruders.values(): #Only register the extruders if we're sure that all of them are correct.
             registry.addContainer(new_extruder)
@@ -136,19 +100,73 @@ class CuraStackBuilder:
 
         return new_global_stack
 
+    ##  Create a default Extruder Stack
+    #
+    #   \param global_stack The global stack this extruder refers to.
+    #   \param extruder_position The position of the current extruder.
+    @classmethod
+    def createExtruderStackWithDefaultSetup(cls, global_stack: "GlobalStack", extruder_position: int) -> None:
+        from cura.CuraApplication import CuraApplication
+        application = CuraApplication.getInstance()
+        variant_manager = application.getVariantManager()
+        material_manager = application.getMaterialManager()
+        registry = application.getContainerRegistry()
+
+        # get variant container for extruders
+        extruder_variant_container = application.empty_variant_container
+        extruder_variant_node = variant_manager.getDefaultVariantNode(global_stack.definition, VariantType.NOZZLE,
+                                                                      global_stack = global_stack)
+        extruder_variant_name = None
+        if extruder_variant_node:
+            extruder_variant_container = extruder_variant_node.getContainer()
+            if not extruder_variant_container:
+                extruder_variant_container = application.empty_variant_container
+            extruder_variant_name = extruder_variant_container.getName()
+
+        extruder_definition_dict = global_stack.getMetaDataEntry("machine_extruder_trains")
+        extruder_definition_id = extruder_definition_dict[str(extruder_position)]
+        extruder_definition = registry.findDefinitionContainers(id = extruder_definition_id)[0]
+
+        # get material container for extruders
+        material_container = application.empty_material_container
+        material_node = material_manager.getDefaultMaterial(global_stack, str(extruder_position), extruder_variant_name,
+                                                            extruder_definition = extruder_definition)
+        if material_node and material_node.getContainer():
+            material_container = material_node.getContainer()
+
+        new_extruder_id = registry.uniqueName(extruder_definition_id)
+        new_extruder = cls.createExtruderStack(
+            new_extruder_id,
+            extruder_definition = extruder_definition,
+            machine_definition_id = global_stack.definition.getId(),
+            position = extruder_position,
+            variant_container = extruder_variant_container,
+            material_container = material_container,
+            quality_container = application.empty_quality_container
+        )
+        new_extruder.setNextStack(global_stack)
+
+        registry.addContainer(new_extruder)
+
     ##  Create a new Extruder stack
     #
     #   \param new_stack_id The ID of the new stack.
-    #   \param definition The definition to base the new stack on.
-    #   \param machine_definition_id The ID of the machine definition to use for
-    #   the user container.
-    #   \param kwargs You can add keyword arguments to specify IDs of containers to use for a specific type, for example "variant": "0.4mm"
+    #   \param extruder_definition The definition to base the new stack on.
+    #   \param machine_definition_id The ID of the machine definition to use for the user container.
+    #   \param position The position the extruder occupies in the machine.
+    #   \param variant_container The variant selected for the current extruder.
+    #   \param material_container The material selected for the current extruder.
+    #   \param quality_container The quality selected for the current extruder.
     #
-    #   \return A new Global stack instance with the specified parameters.
+    #   \return A new Extruder stack instance with the specified parameters.
     @classmethod
-    def createExtruderStack(cls, new_stack_id: str, extruder_definition: DefinitionContainerInterface, machine_definition_id: str,
+    def createExtruderStack(cls, new_stack_id: str, extruder_definition: DefinitionContainerInterface,
+                            machine_definition_id: str,
                             position: int,
-                            variant_container, material_container, quality_container) -> ExtruderStack:
+                            variant_container: "InstanceContainer",
+                            material_container: "InstanceContainer",
+                            quality_container: "InstanceContainer") -> ExtruderStack:
+
         from cura.CuraApplication import CuraApplication
         application = CuraApplication.getInstance()
         registry = application.getContainerRegistry()
@@ -157,7 +175,7 @@ class CuraStackBuilder:
         stack.setName(extruder_definition.getName())
         stack.setDefinition(extruder_definition)
 
-        stack.setMetaDataEntry("position", position)
+        stack.setMetaDataEntry("position", str(position))
 
         user_container = cls.createUserChangesContainer(new_stack_id + "_user", machine_definition_id, new_stack_id,
                                                         is_global_stack = False)
@@ -183,9 +201,22 @@ class CuraStackBuilder:
     #   \param kwargs You can add keyword arguments to specify IDs of containers to use for a specific type, for example "variant": "0.4mm"
     #
     #   \return A new Global stack instance with the specified parameters.
+
+    ##  Create a new Global stack
+    #
+    #   \param new_stack_id The ID of the new stack.
+    #   \param definition The definition to base the new stack on.
+    #   \param variant_container The variant selected for the current stack.
+    #   \param material_container The material selected for the current stack.
+    #   \param quality_container The quality selected for the current stack.
+    #
+    #   \return A new Global stack instance with the specified parameters.
     @classmethod
     def createGlobalStack(cls, new_stack_id: str, definition: DefinitionContainerInterface,
-                          variant_container, material_container, quality_container) -> GlobalStack:
+                          variant_container: "InstanceContainer",
+                          material_container: "InstanceContainer",
+                          quality_container: "InstanceContainer") -> GlobalStack:
+
         from cura.CuraApplication import CuraApplication
         application = CuraApplication.getInstance()
         registry = application.getContainerRegistry()

cura/Settings/ExtruderManager.py

@@ -4,23 +4,20 @@
 from PyQt5.QtCore import pyqtSignal, pyqtProperty, QObject, QVariant  # For communicating data and events to Qt.
 from UM.FlameProfiler import pyqtSlot
 
-import cura.CuraApplication #To get the global container stack to find the current machine.
+import cura.CuraApplication # To get the global container stack to find the current machine.
+from cura.Settings.GlobalStack import GlobalStack
 from UM.Logger import Logger
 from UM.Scene.Iterator.DepthFirstIterator import DepthFirstIterator
 from UM.Scene.SceneNode import SceneNode
 from UM.Scene.Selection import Selection
 from UM.Scene.Iterator.BreadthFirstIterator import BreadthFirstIterator
 from UM.Settings.ContainerRegistry import ContainerRegistry  # Finding containers by ID.
-from UM.Settings.SettingFunction import SettingFunction
-from UM.Settings.SettingInstance import SettingInstance
 from UM.Settings.ContainerStack import ContainerStack
-from UM.Settings.PropertyEvaluationContext import PropertyEvaluationContext
 
-from typing import Optional, List, TYPE_CHECKING, Union, Dict
+from typing import Any, cast, Dict, List, Optional, TYPE_CHECKING, Union
 
 if TYPE_CHECKING:
     from cura.Settings.ExtruderStack import ExtruderStack
-    from cura.Settings.GlobalStack import GlobalStack
 
 
 ##  Manages all existing extruder stacks.
@@ -38,9 +35,13 @@ class ExtruderManager(QObject):
 
         self._application = cura.CuraApplication.CuraApplication.getInstance()
 
-        self._extruder_trains = {}  # Per machine, a dictionary of extruder container stack IDs. Only for separately defined extruders.
+        # Per machine, a dictionary of extruder container stack IDs. Only for separately defined extruders.
+        self._extruder_trains = {}  # type: Dict[str, Dict[str, "ExtruderStack"]]
         self._active_extruder_index = -1  # Indicates the index of the active extruder stack. -1 means no active extruder stack
-        self._selected_object_extruders = []
+
+        # TODO; I have no idea why this is a union of ID's and extruder stacks. This needs to be fixed at some point.
+        self._selected_object_extruders = []  # type: List[Union[str, "ExtruderStack"]]
+
         self._addCurrentMachineExtruders()
 
         Selection.selectionChanged.connect(self.resetSelectedObjectExtruders)
@@ -62,52 +63,29 @@ class ExtruderManager(QObject):
         if not self._application.getGlobalContainerStack():
             return None  # No active machine, so no active extruder.
         try:
-            return self._extruder_trains[self._application.getGlobalContainerStack().getId()][str(self._active_extruder_index)].getId()
+            return self._extruder_trains[self._application.getGlobalContainerStack().getId()][str(self.activeExtruderIndex)].getId()
         except KeyError:  # Extruder index could be -1 if the global tab is selected, or the entry doesn't exist if the machine definition is wrong.
             return None
 
-    ##  Return extruder count according to extruder trains.
-    @pyqtProperty(int, notify = extrudersChanged)
-    def extruderCount(self):
-        if not self._application.getGlobalContainerStack():
-            return 0  # No active machine, so no extruders.
-        try:
-            return len(self._extruder_trains[self._application.getGlobalContainerStack().getId()])
-        except KeyError:
-            return 0
-
     ##  Gets a dict with the extruder stack ids with the extruder number as the key.
     @pyqtProperty("QVariantMap", notify = extrudersChanged)
     def extruderIds(self) -> Dict[str, str]:
-        extruder_stack_ids = {}
+        extruder_stack_ids = {}  # type: Dict[str, str]
 
         global_container_stack = self._application.getGlobalContainerStack()
         if global_container_stack:
-            global_stack_id = global_container_stack.getId()
-
-            if global_stack_id in self._extruder_trains:
-                for position in self._extruder_trains[global_stack_id]:
-                    extruder_stack_ids[position] = self._extruder_trains[global_stack_id][position].getId()
+            extruder_stack_ids = {position: extruder.id for position, extruder in global_container_stack.extruders.items()}
 
         return extruder_stack_ids
 
-    @pyqtSlot(str, result = str)
-    def getQualityChangesIdByExtruderStackId(self, extruder_stack_id: str) -> str:
-        global_container_stack = self._application.getGlobalContainerStack()
-        if global_container_stack is not None:
-            for position in self._extruder_trains[global_container_stack.getId()]:
-                extruder = self._extruder_trains[global_container_stack.getId()][position]
-                if extruder.getId() == extruder_stack_id:
-                    return extruder.qualityChanges.getId()
-        return ""
-
     ##  Changes the active extruder by index.
     #
     #   \param index The index of the new active extruder.
     @pyqtSlot(int)
     def setActiveExtruderIndex(self, index: int) -> None:
-        self._active_extruder_index = index
-        self.activeExtruderChanged.emit()
+        if self._active_extruder_index != index:
+            self._active_extruder_index = index
+            self.activeExtruderChanged.emit()
 
     @pyqtProperty(int, notify = activeExtruderChanged)
     def activeExtruderIndex(self) -> int:
@@ -117,9 +95,9 @@ class ExtruderManager(QObject):
     #
     #   \param index The index of the extruder whose name to get.
     @pyqtSlot(int, result = str)
-    def getExtruderName(self, index):
+    def getExtruderName(self, index: int) -> str:
         try:
-            return list(self.getActiveExtruderStacks())[index].getName()
+            return self.getActiveExtruderStacks()[index].getName()
         except IndexError:
             return ""
 
@@ -128,12 +106,12 @@ class ExtruderManager(QObject):
 
     ##  Provides a list of extruder IDs used by the current selected objects.
     @pyqtProperty("QVariantList", notify = selectedObjectExtrudersChanged)
-    def selectedObjectExtruders(self) -> List[str]:
+    def selectedObjectExtruders(self) -> List[Union[str, "ExtruderStack"]]:
         if not self._selected_object_extruders:
             object_extruders = set()
 
             # First, build a list of the actual selected objects (including children of groups, excluding group nodes)
-            selected_nodes = []
+            selected_nodes = []  # type: List["SceneNode"]
             for node in Selection.getAllSelectedObjects():
                 if node.callDecoration("isGroup"):
                     for grouped_node in BreadthFirstIterator(node): #type: ignore #Ignore type error because iter() should get called automatically by Python syntax.
@@ -145,16 +123,15 @@ class ExtruderManager(QObject):
                     selected_nodes.append(node)
 
             # Then, figure out which nodes are used by those selected nodes.
-            global_stack = self._application.getGlobalContainerStack()
-            current_extruder_trains = self._extruder_trains.get(global_stack.getId())
+            current_extruder_trains = self.getActiveExtruderStacks()
             for node in selected_nodes:
                 extruder = node.callDecoration("getActiveExtruder")
                 if extruder:
                     object_extruders.add(extruder)
                 elif current_extruder_trains:
-                    object_extruders.add(current_extruder_trains["0"].getId())
+                    object_extruders.add(current_extruder_trains[0].getId())
 
-            self._selected_object_extruders = list(object_extruders)
+            self._selected_object_extruders = list(object_extruders)  # type: List[Union[str, "ExtruderStack"]]
 
         return self._selected_object_extruders
 
@@ -163,19 +140,12 @@ class ExtruderManager(QObject):
     #   This will trigger a recalculation of the extruders used for the
     #   selection.
     def resetSelectedObjectExtruders(self) -> None:
-        self._selected_object_extruders = []
+        self._selected_object_extruders = []  # type: List[Union[str, "ExtruderStack"]]
         self.selectedObjectExtrudersChanged.emit()
 
     @pyqtSlot(result = QObject)
     def getActiveExtruderStack(self) -> Optional["ExtruderStack"]:
-        global_container_stack = self._application.getGlobalContainerStack()
-
-        if global_container_stack:
-            if global_container_stack.getId() in self._extruder_trains:
-                if str(self._active_extruder_index) in self._extruder_trains[global_container_stack.getId()]:
-                    return self._extruder_trains[global_container_stack.getId()][str(self._active_extruder_index)]
-
-        return None
+        return self.getExtruderStack(self.activeExtruderIndex)
 
     ##  Get an extruder stack by index
     def getExtruderStack(self, index) -> Optional["ExtruderStack"]:
@@ -186,16 +156,7 @@ class ExtruderManager(QObject):
                     return self._extruder_trains[global_container_stack.getId()][str(index)]
         return None
 
-    ##  Get all extruder stacks
-    def getExtruderStacks(self) -> List["ExtruderStack"]:
-        result = []
-        for i in range(self.extruderCount):
-            stack = self.getExtruderStack(i)
-            if stack:
-                result.append(stack)
-        return result
-
-    def registerExtruder(self, extruder_train, machine_id):
+    def registerExtruder(self, extruder_train: "ExtruderStack", machine_id: str) -> None:
         changed = False
 
         if machine_id not in self._extruder_trains:
@@ -214,23 +175,20 @@ class ExtruderManager(QObject):
         if changed:
             self.extrudersChanged.emit(machine_id)
 
-    def getAllExtruderValues(self, setting_key):
-        return self.getAllExtruderSettings(setting_key, "value")
-
     ##  Gets a property of a setting for all extruders.
     #
     #   \param setting_key  \type{str} The setting to get the property of.
     #   \param property  \type{str} The property to get.
     #   \return \type{List} the list of results
-    def getAllExtruderSettings(self, setting_key: str, prop: str):
+    def getAllExtruderSettings(self, setting_key: str, prop: str) -> List:
         result = []
-        for index in self.extruderIds:
-            extruder_stack_id = self.extruderIds[str(index)]
-            extruder_stack = ContainerRegistry.getInstance().findContainerStacks(id = extruder_stack_id)[0]
+
+        for extruder_stack in self.getActiveExtruderStacks():
             result.append(extruder_stack.getProperty(setting_key, prop))
+
         return result
 
-    def extruderValueWithDefault(self, value):
+    def extruderValueWithDefault(self, value: str) -> str:
         machine_manager = self._application.getMachineManager()
         if value == "-1":
             return machine_manager.defaultExtruderPosition
@@ -306,7 +264,9 @@ class ExtruderManager(QObject):
                 used_extruder_stack_ids.add(self.extruderIds[self.extruderValueWithDefault(str(global_stack.getProperty("support_roof_extruder_nr", "value")))])
 
         # The platform adhesion extruder. Not used if using none.
-        if global_stack.getProperty("adhesion_type", "value") != "none":
+        if global_stack.getProperty("adhesion_type", "value") != "none" or (
+                global_stack.getProperty("prime_tower_brim_enable", "value") and
+                global_stack.getProperty("adhesion_type", "value") != 'raft'):
             extruder_str_nr = str(global_stack.getProperty("adhesion_extruder_nr", "value"))
             if extruder_str_nr == "-1":
                 extruder_str_nr = self._application.getMachineManager().defaultExtruderPosition
@@ -321,7 +281,7 @@ class ExtruderManager(QObject):
     ##  Removes the container stack and user profile for the extruders for a specific machine.
     #
     #   \param machine_id The machine to remove the extruders for.
-    def removeMachineExtruders(self, machine_id: str):
+    def removeMachineExtruders(self, machine_id: str) -> None:
         for extruder in self.getMachineExtruders(machine_id):
             ContainerRegistry.getInstance().removeContainer(extruder.userChanges.getId())
             ContainerRegistry.getInstance().removeContainer(extruder.getId())
@@ -331,24 +291,11 @@ class ExtruderManager(QObject):
     ##  Returns extruders for a specific machine.
     #
     #   \param machine_id The machine to get the extruders of.
-    def getMachineExtruders(self, machine_id: str):
+    def getMachineExtruders(self, machine_id: str) -> List["ExtruderStack"]:
         if machine_id not in self._extruder_trains:
             return []
         return [self._extruder_trains[machine_id][name] for name in self._extruder_trains[machine_id]]
 
-    ##  Returns a list containing the global stack and active extruder stacks.
-    #
-    #   The first element is the global container stack, followed by any extruder stacks.
-    #   \return \type{List[ContainerStack]}
-    def getActiveGlobalAndExtruderStacks(self) -> Optional[List[Union["ExtruderStack", "GlobalStack"]]]:
-        global_stack = self._application.getGlobalContainerStack()
-        if not global_stack:
-            return None
-
-        result = [global_stack]
-        result.extend(self.getActiveExtruderStacks())
-        return result
-
     ##  Returns the list of active extruder stacks, taking into account the machine extruder count.
     #
     #   \return \type{List[ContainerStack]} a list of
@@ -356,15 +303,7 @@ class ExtruderManager(QObject):
         global_stack = self._application.getGlobalContainerStack()
         if not global_stack:
             return []
-
-        result = []
-        if global_stack.getId() in self._extruder_trains:
-            for extruder in sorted(self._extruder_trains[global_stack.getId()]):
-                result.append(self._extruder_trains[global_stack.getId()][extruder])
-
-        machine_extruder_count = global_stack.getProperty("machine_extruder_count", "value")
-
-        return result[:machine_extruder_count]
+        return global_stack.extruderList
 
     def _globalContainerStackChanged(self) -> None:
         # If the global container changed, the machine changed and might have extruders that were not registered yet
@@ -403,99 +342,37 @@ class ExtruderManager(QObject):
             if extruders_changed:
                 self.extrudersChanged.emit(global_stack_id)
                 self.setActiveExtruderIndex(0)
+                self.activeExtruderChanged.emit()
 
     # After 3.4, all single-extrusion machines have their own extruder definition files instead of reusing
     # "fdmextruder". We need to check a machine here so its extruder definition is correct according to this.
-    def _fixSingleExtrusionMachineExtruderDefinition(self, global_stack):
+    def _fixSingleExtrusionMachineExtruderDefinition(self, global_stack: "GlobalStack") -> None:
+        container_registry = ContainerRegistry.getInstance()
         expected_extruder_definition_0_id = global_stack.getMetaDataEntry("machine_extruder_trains")["0"]
-        extruder_stack_0 = global_stack.extruders["0"]
-        if extruder_stack_0.definition.getId() != expected_extruder_definition_0_id:
+        extruder_stack_0 = global_stack.extruders.get("0")
+        # At this point, extruder stacks for this machine may not have been loaded yet. In this case, need to look in
+        # the container registry as well.
+        if not global_stack.extruders:
+            extruder_trains = container_registry.findContainerStacks(type = "extruder_train",
+                                                                     machine = global_stack.getId())
+            if extruder_trains:
+                for extruder in extruder_trains:
+                    if extruder.getMetaDataEntry("position") == "0":
+                        extruder_stack_0 = extruder
+                        break
+
+        if extruder_stack_0 is None:
+            Logger.log("i", "No extruder stack for global stack [%s], create one", global_stack.getId())
+            # Single extrusion machine without an ExtruderStack, create it
+            from cura.Settings.CuraStackBuilder import CuraStackBuilder
+            CuraStackBuilder.createExtruderStackWithDefaultSetup(global_stack, 0)
+
+        elif extruder_stack_0.definition.getId() != expected_extruder_definition_0_id:
             Logger.log("e", "Single extruder printer [{printer}] expected extruder [{expected}], but got [{got}]. I'm making it [{expected}].".format(
                 printer = global_stack.getId(), expected = expected_extruder_definition_0_id, got = extruder_stack_0.definition.getId()))
-            container_registry = ContainerRegistry.getInstance()
             extruder_definition = container_registry.findDefinitionContainers(id = expected_extruder_definition_0_id)[0]
             extruder_stack_0.definition = extruder_definition
 
-    ##  Get all extruder values for a certain setting.
-    #
-    #   This is exposed to SettingFunction so it can be used in value functions.
-    #
-    #   \param key The key of the setting to retrieve values for.
-    #
-    #   \return A list of values for all extruders. If an extruder does not have a value, it will not be in the list.
-    #           If no extruder has the value, the list will contain the global value.
-    @staticmethod
-    def getExtruderValues(key):
-        global_stack = cura.CuraApplication.CuraApplication.getInstance().getGlobalContainerStack()
-
-        result = []
-        for extruder in ExtruderManager.getInstance().getMachineExtruders(global_stack.getId()):
-            if not extruder.isEnabled:
-                continue
-            # only include values from extruders that are "active" for the current machine instance
-            if int(extruder.getMetaDataEntry("position")) >= global_stack.getProperty("machine_extruder_count", "value"):
-                continue
-
-            value = extruder.getRawProperty(key, "value")
-
-            if value is None:
-                continue
-
-            if isinstance(value, SettingFunction):
-                value = value(extruder)
-
-            result.append(value)
-
-        if not result:
-            result.append(global_stack.getProperty(key, "value"))
-
-        return result
-
-    ##  Get all extruder values for a certain setting. This function will skip the user settings container.
-    #
-    #   This is exposed to SettingFunction so it can be used in value functions.
-    #
-    #   \param key The key of the setting to retrieve values for.
-    #
-    #   \return A list of values for all extruders. If an extruder does not have a value, it will not be in the list.
-    #           If no extruder has the value, the list will contain the global value.
-    @staticmethod
-    def getDefaultExtruderValues(key):
-        global_stack = cura.CuraApplication.CuraApplication.getInstance().getGlobalContainerStack()
-        context = PropertyEvaluationContext(global_stack)
-        context.context["evaluate_from_container_index"] = 1  # skip the user settings container
-        context.context["override_operators"] = {
-            "extruderValue": ExtruderManager.getDefaultExtruderValue,
-            "extruderValues": ExtruderManager.getDefaultExtruderValues,
-            "resolveOrValue": ExtruderManager.getDefaultResolveOrValue
-        }
-
-        result = []
-        for extruder in ExtruderManager.getInstance().getMachineExtruders(global_stack.getId()):
-            # only include values from extruders that are "active" for the current machine instance
-            if int(extruder.getMetaDataEntry("position")) >= global_stack.getProperty("machine_extruder_count", "value", context = context):
-                continue
-
-            value = extruder.getRawProperty(key, "value", context = context)
-
-            if value is None:
-                continue
-
-            if isinstance(value, SettingFunction):
-                value = value(extruder, context = context)
-
-            result.append(value)
-
-        if not result:
-            result.append(global_stack.getProperty(key, "value", context = context))
-
-        return result
-
-    ##  Return the default extruder position from the machine manager
-    @staticmethod
-    def getDefaultExtruderPosition() -> str:
-        return cura.CuraApplication.CuraApplication.getInstance().getMachineManager().defaultExtruderPosition
-
     ##  Get all extruder values for a certain setting.
     #
     #   This is exposed to qml for display purposes
@@ -504,62 +381,8 @@ class ExtruderManager(QObject):
     #
     #   \return String representing the extruder values
     @pyqtSlot(str, result="QVariant")
-    def getInstanceExtruderValues(self, key):
-        return ExtruderManager.getExtruderValues(key)
-
-    ##  Get the value for a setting from a specific extruder.
-    #
-    #   This is exposed to SettingFunction to use in value functions.
-    #
-    #   \param extruder_index The index of the extruder to get the value from.
-    #   \param key The key of the setting to get the value of.
-    #
-    #   \return The value of the setting for the specified extruder or for the
-    #   global stack if not found.
-    @staticmethod
-    def getExtruderValue(extruder_index, key):
-        if extruder_index == -1:
-            extruder_index = int(cura.CuraApplication.CuraApplication.getInstance().getMachineManager().defaultExtruderPosition)
-        extruder = ExtruderManager.getInstance().getExtruderStack(extruder_index)
-
-        if extruder:
-            value = extruder.getRawProperty(key, "value")
-            if isinstance(value, SettingFunction):
-                value = value(extruder)
-        else:
-            # Just a value from global.
-            value = cura.CuraApplication.CuraApplication.getInstance().getGlobalContainerStack().getProperty(key, "value")
-
-        return value
-
-    ##  Get the default value from the given extruder. This function will skip the user settings container.
-    #
-    #   This is exposed to SettingFunction to use in value functions.
-    #
-    #   \param extruder_index The index of the extruder to get the value from.
-    #   \param key The key of the setting to get the value of.
-    #
-    #   \return The value of the setting for the specified extruder or for the
-    #   global stack if not found.
-    @staticmethod
-    def getDefaultExtruderValue(extruder_index, key):
-        extruder = ExtruderManager.getInstance().getExtruderStack(extruder_index)
-        context = PropertyEvaluationContext(extruder)
-        context.context["evaluate_from_container_index"] = 1  # skip the user settings container
-        context.context["override_operators"] = {
-            "extruderValue": ExtruderManager.getDefaultExtruderValue,
-            "extruderValues": ExtruderManager.getDefaultExtruderValues,
-            "resolveOrValue": ExtruderManager.getDefaultResolveOrValue
-        }
-
-        if extruder:
-            value = extruder.getRawProperty(key, "value", context = context)
-            if isinstance(value, SettingFunction):
-                value = value(extruder, context = context)
-        else:  # Just a value from global.
-            value = cura.CuraApplication.CuraApplication.getInstance().getGlobalContainerStack().getProperty(key, "value", context = context)
-
-        return value
+    def getInstanceExtruderValues(self, key: str) -> List:
+        return self._application.getCuraFormulaFunctions().getValuesInAllExtruders(key)
 
     ##  Get the resolve value or value for a given key
     #
@@ -569,34 +392,12 @@ class ExtruderManager(QObject):
     #
     #   \return The effective value
     @staticmethod
-    def getResolveOrValue(key):
-        global_stack = cura.CuraApplication.CuraApplication.getInstance().getGlobalContainerStack()
+    def getResolveOrValue(key: str) -> Any:
+        global_stack = cast(GlobalStack, cura.CuraApplication.CuraApplication.getInstance().getGlobalContainerStack())
         resolved_value = global_stack.getProperty(key, "value")
 
         return resolved_value
 
-    ##  Get the resolve value or value for a given key without looking the first container (user container)
-    #
-    #   This is the effective value for a given key, it is used for values in the global stack.
-    #   This is exposed to SettingFunction to use in value functions.
-    #   \param key The key of the setting to get the value of.
-    #
-    #   \return The effective value
-    @staticmethod
-    def getDefaultResolveOrValue(key):
-        global_stack = cura.CuraApplication.CuraApplication.getInstance().getGlobalContainerStack()
-        context = PropertyEvaluationContext(global_stack)
-        context.context["evaluate_from_container_index"] = 1  # skip the user settings container
-        context.context["override_operators"] = {
-            "extruderValue": ExtruderManager.getDefaultExtruderValue,
-            "extruderValues": ExtruderManager.getDefaultExtruderValues,
-            "resolveOrValue": ExtruderManager.getDefaultResolveOrValue
-        }
-
-        resolved_value = global_stack.getProperty(key, "value", context = context)
-
-        return resolved_value
-
     __instance = None   # type: ExtruderManager
 
     @classmethod

cura/Settings/ExtruderStack.py

@@ -52,8 +52,8 @@ class ExtruderStack(CuraContainerStack):
         return super().getNextStack()
 
     def setEnabled(self, enabled: bool) -> None:
-        if "enabled" not in self._metadata:
-            self.setMetaDataEntry("enabled", "True")
+        if self.getMetaDataEntry("enabled", True) == enabled: # No change.
+            return # Don't emit a signal then.
         self.setMetaDataEntry("enabled", str(enabled))
         self.enabledChanged.emit()
 
@@ -65,16 +65,33 @@ class ExtruderStack(CuraContainerStack):
     def getLoadingPriority(cls) -> int:
         return 3
 
+    compatibleMaterialDiameterChanged = pyqtSignal()
+
     ##  Return the filament diameter that the machine requires.
     #
     #   If the machine has no requirement for the diameter, -1 is returned.
     #   \return The filament diameter for the printer
-    @property
-    def materialDiameter(self) -> float:
+    def getCompatibleMaterialDiameter(self) -> float:
         context = PropertyEvaluationContext(self)
         context.context["evaluate_from_container_index"] = _ContainerIndexes.Variant
 
-        return self.getProperty("material_diameter", "value", context = context)
+        return float(self.getProperty("material_diameter", "value", context = context))
+
+    def setCompatibleMaterialDiameter(self, value: float) -> None:
+        old_approximate_diameter = self.getApproximateMaterialDiameter()
+        if self.getCompatibleMaterialDiameter() != value:
+            self.definitionChanges.setProperty("material_diameter", "value", value)
+            self.compatibleMaterialDiameterChanged.emit()
+
+            # Emit approximate diameter changed signal if needed
+            if old_approximate_diameter != self.getApproximateMaterialDiameter():
+                self.approximateMaterialDiameterChanged.emit()
+
+    compatibleMaterialDiameter = pyqtProperty(float, fset = setCompatibleMaterialDiameter,
+                                              fget = getCompatibleMaterialDiameter,
+                                              notify = compatibleMaterialDiameterChanged)
+
+    approximateMaterialDiameterChanged = pyqtSignal()
 
     ##  Return the approximate filament diameter that the machine requires.
     #
@@ -84,9 +101,11 @@ class ExtruderStack(CuraContainerStack):
     #   If the machine has no requirement for the diameter, -1 is returned.
     #
     #   \return The approximate filament diameter for the printer
-    @pyqtProperty(float)
-    def approximateMaterialDiameter(self) -> float:
-        return round(float(self.materialDiameter))
+    def getApproximateMaterialDiameter(self) -> float:
+        return round(self.getCompatibleMaterialDiameter())
+
+    approximateMaterialDiameter = pyqtProperty(float, fget = getApproximateMaterialDiameter,
+                                               notify = approximateMaterialDiameterChanged)
 
     ##  Overridden from ContainerStack
     #

cura/Settings/ExtrudersModel.py

@@ -1,7 +1,7 @@
-# Copyright (c) 2017 Ultimaker B.V.
+# Copyright (c) 2018 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
 
-from PyQt5.QtCore import Qt, pyqtSignal, pyqtSlot, pyqtProperty, QTimer
+from PyQt5.QtCore import Qt, pyqtSignal, pyqtProperty, QTimer
 from typing import Iterable
 
 from UM.i18n import i18nCatalog
@@ -24,8 +24,6 @@ class ExtrudersModel(UM.Qt.ListModel.ListModel):
 
     ##  Human-readable name of the extruder.
     NameRole = Qt.UserRole + 2
-    ##  Is the extruder enabled?
-    EnabledRole = Qt.UserRole + 9
 
     ##  Colour of the material loaded in the extruder.
     ColorRole = Qt.UserRole + 3
@@ -47,6 +45,12 @@ class ExtrudersModel(UM.Qt.ListModel.ListModel):
     VariantRole = Qt.UserRole + 7
     StackRole = Qt.UserRole + 8
 
+    MaterialBrandRole = Qt.UserRole + 9
+    ColorNameRole = Qt.UserRole + 10
+
+    ##  Is the extruder enabled?
+    EnabledRole = Qt.UserRole + 11
+
     ##  List of colours to display if there is no material or the material has no known
     #   colour.
     defaultColors = ["#ffc924", "#86ec21", "#22eeee", "#245bff", "#9124ff", "#ff24c8"]
@@ -67,14 +71,13 @@ class ExtrudersModel(UM.Qt.ListModel.ListModel):
         self.addRoleName(self.MaterialRole, "material")
         self.addRoleName(self.VariantRole, "variant")
         self.addRoleName(self.StackRole, "stack")
-
+        self.addRoleName(self.MaterialBrandRole, "material_brand")
+        self.addRoleName(self.ColorNameRole, "color_name")
         self._update_extruder_timer = QTimer()
         self._update_extruder_timer.setInterval(100)
         self._update_extruder_timer.setSingleShot(True)
         self._update_extruder_timer.timeout.connect(self.__updateExtruders)
 
-        self._simple_names = False
-
         self._active_machine_extruders = []  # type: Iterable[ExtruderStack]
         self._add_optional_extruder = False
 
@@ -96,21 +99,6 @@ class ExtrudersModel(UM.Qt.ListModel.ListModel):
     def addOptionalExtruder(self):
         return self._add_optional_extruder
 
-    ##  Set the simpleNames property.
-    def setSimpleNames(self, simple_names):
-        if simple_names != self._simple_names:
-            self._simple_names = simple_names
-            self.simpleNamesChanged.emit()
-            self._updateExtruders()
-
-    ##  Emitted when the simpleNames property changes.
-    simpleNamesChanged = pyqtSignal()
-
-    ##  Whether or not the model should show all definitions regardless of visibility.
-    @pyqtProperty(bool, fset = setSimpleNames, notify = simpleNamesChanged)
-    def simpleNames(self):
-        return self._simple_names
-
     ##  Links to the stack-changed signal of the new extruders when an extruder
     #   is swapped out or added in the current machine.
     #
@@ -119,25 +107,28 @@ class ExtrudersModel(UM.Qt.ListModel.ListModel):
     #   that signal. Application.globalContainerStackChanged doesn't fill this
     #   signal; it's assumed to be the current printer in that case.
     def _extrudersChanged(self, machine_id = None):
+        machine_manager = Application.getInstance().getMachineManager()
         if machine_id is not None:
-            if Application.getInstance().getGlobalContainerStack() is None:
+            if machine_manager.activeMachine is None:
                 # No machine, don't need to update the current machine's extruders
                 return
-            if machine_id != Application.getInstance().getGlobalContainerStack().getId():
+            if machine_id != machine_manager.activeMachine.getId():
                 # Not the current machine
                 return
 
         # Unlink from old extruders
         for extruder in self._active_machine_extruders:
             extruder.containersChanged.disconnect(self._onExtruderStackContainersChanged)
+            extruder.enabledChanged.disconnect(self._updateExtruders)
 
         # Link to new extruders
         self._active_machine_extruders = []
         extruder_manager = Application.getInstance().getExtruderManager()
-        for extruder in extruder_manager.getExtruderStacks():
+        for extruder in extruder_manager.getActiveExtruderStacks():
             if extruder is None: #This extruder wasn't loaded yet. This happens asynchronously while this model is constructed from QML.
                 continue
             extruder.containersChanged.connect(self._onExtruderStackContainersChanged)
+            extruder.enabledChanged.connect(self._updateExtruders)
             self._active_machine_extruders.append(extruder)
 
         self._updateExtruders()  # Since the new extruders may have different properties, update our own model.
@@ -160,7 +151,7 @@ class ExtrudersModel(UM.Qt.ListModel.ListModel):
     def __updateExtruders(self):
         extruders_changed = False
 
-        if self.rowCount() != 0:
+        if self.count != 0:
             extruders_changed = True
 
         items = []
@@ -171,8 +162,8 @@ class ExtrudersModel(UM.Qt.ListModel.ListModel):
             # get machine extruder count for verification
             machine_extruder_count = global_container_stack.getProperty("machine_extruder_count", "value")
 
-            for extruder in Application.getInstance().getExtruderManager().getMachineExtruders(global_container_stack.getId()):
-                position = extruder.getMetaDataEntry("position", default = "0")  # Get the position
+            for extruder in Application.getInstance().getExtruderManager().getActiveExtruderStacks():
+                position = extruder.getMetaDataEntry("position", default = "0")
                 try:
                     position = int(position)
                 except ValueError:
@@ -183,7 +174,8 @@ class ExtrudersModel(UM.Qt.ListModel.ListModel):
 
                 default_color = self.defaultColors[position] if 0 <= position < len(self.defaultColors) else self.defaultColors[0]
                 color = extruder.material.getMetaDataEntry("color_code", default = default_color) if extruder.material else default_color
-
+                material_brand = extruder.material.getMetaDataEntry("brand", default = "generic")
+                color_name = extruder.material.getMetaDataEntry("color_name")
                 # construct an item with only the relevant information
                 item = {
                     "id": extruder.getId(),
@@ -195,6 +187,8 @@ class ExtrudersModel(UM.Qt.ListModel.ListModel):
                     "material": extruder.material.getName() if extruder.material else "",
                     "variant": extruder.variant.getName() if extruder.variant else "",  # e.g. print core
                     "stack": extruder,
+                    "material_brand": material_brand,
+                    "color_name": color_name
                 }
 
                 items.append(item)
@@ -213,9 +207,14 @@ class ExtrudersModel(UM.Qt.ListModel.ListModel):
                     "enabled": True,
                     "color": "#ffffff",
                     "index": -1,
-                    "definition": ""
+                    "definition": "",
+                    "material": "",
+                    "variant": "",
+                    "stack": None,
+                    "material_brand": "",
+                    "color_name": "",
                 }
                 items.append(item)
-
-            self.setItems(items)
-            self.modelChanged.emit()
+            if self._items != items:
+                self.setItems(items)
+                self.modelChanged.emit()

cura/Settings/GlobalStack.py

@@ -3,8 +3,8 @@
 
 from collections import defaultdict
 import threading
-from typing import Any, Dict, Optional, Set, TYPE_CHECKING
-from PyQt5.QtCore import pyqtProperty
+from typing import Any, Dict, Optional, Set, TYPE_CHECKING, List
+from PyQt5.QtCore import pyqtProperty, pyqtSlot, pyqtSignal
 
 from UM.Decorators import override
 from UM.MimeTypeDatabase import MimeType, MimeTypeDatabase
@@ -13,6 +13,10 @@ from UM.Settings.SettingInstance import InstanceState
 from UM.Settings.ContainerRegistry import ContainerRegistry
 from UM.Settings.Interfaces import PropertyEvaluationContext
 from UM.Logger import Logger
+from UM.Resources import Resources
+from UM.Platform import Platform
+from UM.Util import parseBool
+
 import cura.CuraApplication
 
 from . import Exceptions
@@ -21,6 +25,7 @@ from .CuraContainerStack import CuraContainerStack
 if TYPE_CHECKING:
     from cura.Settings.ExtruderStack import ExtruderStack
 
+
 ##  Represents the Global or Machine stack and its related containers.
 #
 class GlobalStack(CuraContainerStack):
@@ -37,17 +42,63 @@ class GlobalStack(CuraContainerStack):
         # Per thread we have our own resolving_settings, or strange things sometimes occur.
         self._resolving_settings = defaultdict(set) #type: Dict[str, Set[str]] # keys are thread names
 
+        # Since the metadatachanged is defined in container stack, we can't use it here as a notifier for pyqt
+        # properties. So we need to tie them together like this.
+        self.metaDataChanged.connect(self.configuredConnectionTypesChanged)
+
+    extrudersChanged = pyqtSignal()
+    configuredConnectionTypesChanged = pyqtSignal()
+
     ##  Get the list of extruders of this stack.
     #
     #   \return The extruders registered with this stack.
-    @pyqtProperty("QVariantMap")
+    @pyqtProperty("QVariantMap", notify = extrudersChanged)
     def extruders(self) -> Dict[str, "ExtruderStack"]:
         return self._extruders
 
+    @pyqtProperty("QVariantList", notify = extrudersChanged)
+    def extruderList(self) -> List["ExtruderStack"]:
+        result_tuple_list = sorted(list(self.extruders.items()), key=lambda x: int(x[0]))
+        result_list = [item[1] for item in result_tuple_list]
+
+        machine_extruder_count = self.getProperty("machine_extruder_count", "value")
+        return result_list[:machine_extruder_count]
+
     @classmethod
     def getLoadingPriority(cls) -> int:
         return 2
 
+    ##  The configured connection types can be used to find out if the global
+    #   stack is configured to be connected with a printer, without having to
+    #   know all the details as to how this is exactly done (and without
+    #   actually setting the stack to be active).
+    #
+    #   This data can then in turn also be used when the global stack is active;
+    #   If we can't get a network connection, but it is configured to have one,
+    #   we can display a different icon to indicate the difference.
+    @pyqtProperty("QVariantList", notify=configuredConnectionTypesChanged)
+    def configuredConnectionTypes(self) -> List[int]:
+        # Requesting it from the metadata actually gets them as strings (as that's what you get from serializing).
+        # But we do want them returned as a list of ints (so the rest of the code can directly compare)
+        connection_types = self.getMetaDataEntry("connection_type", "").split(",")
+        return [int(connection_type) for connection_type in connection_types if connection_type != ""]
+
+    ##  \sa configuredConnectionTypes
+    def addConfiguredConnectionType(self, connection_type: int) -> None:
+        configured_connection_types = self.configuredConnectionTypes
+        if connection_type not in configured_connection_types:
+            # Store the values as a string.
+            configured_connection_types.append(connection_type)
+            self.setMetaDataEntry("connection_type", ",".join([str(c_type) for c_type in configured_connection_types]))
+
+    ##  \sa configuredConnectionTypes
+    def removeConfiguredConnectionType(self, connection_type: int) -> None:
+        configured_connection_types = self.configuredConnectionTypes
+        if connection_type in self.configured_connection_types:
+            # Store the values as a string.
+            configured_connection_types.remove(connection_type)
+            self.setMetaDataEntry("connection_type", ",".join([str(c_type) for c_type in configured_connection_types]))
+
     @classmethod
     def getConfigurationTypeFromSerialized(cls, serialized: str) -> Optional[str]:
         configuration_type = super().getConfigurationTypeFromSerialized(serialized)
@@ -61,6 +112,10 @@ class GlobalStack(CuraContainerStack):
             name = self.variant.getName()
         return name
 
+    @pyqtProperty(str, constant = True)
+    def preferred_output_file_formats(self) -> str:
+        return self.getMetaDataEntry("file_formats")
+
     ##  Add an extruder to the list of extruders of this stack.
     #
     #   \param extruder The extruder to add.
@@ -78,6 +133,7 @@ class GlobalStack(CuraContainerStack):
             return
 
         self._extruders[position] = extruder
+        self.extrudersChanged.emit()
         Logger.log("i", "Extruder[%s] added to [%s] at position [%s]", extruder.id, self.id, position)
 
     ##  Overridden from ContainerStack
@@ -184,6 +240,40 @@ class GlobalStack(CuraContainerStack):
     def getHeadAndFansCoordinates(self):
         return self.getProperty("machine_head_with_fans_polygon", "value")
 
+    def getHasMaterials(self) -> bool:
+        return parseBool(self.getMetaDataEntry("has_materials", False))
+
+    def getHasVariants(self) -> bool:
+        return parseBool(self.getMetaDataEntry("has_variants", False))
+
+    def getHasMachineQuality(self) -> bool:
+        return parseBool(self.getMetaDataEntry("has_machine_quality", False))
+
+    ##  Get default firmware file name if one is specified in the firmware
+    @pyqtSlot(result = str)
+    def getDefaultFirmwareName(self) -> str:
+        machine_has_heated_bed = self.getProperty("machine_heated_bed", "value")
+
+        baudrate = 250000
+        if Platform.isLinux():
+            # Linux prefers a baudrate of 115200 here because older versions of
+            # pySerial did not support a baudrate of 250000
+            baudrate = 115200
+
+        # If a firmware file is available, it should be specified in the definition for the printer
+        hex_file = self.getMetaDataEntry("firmware_file", None)
+        if machine_has_heated_bed:
+            hex_file = self.getMetaDataEntry("firmware_hbk_file", hex_file)
+
+        if not hex_file:
+            Logger.log("w", "There is no firmware for machine %s.", self.getBottom().id)
+            return ""
+
+        try:
+            return Resources.getPath(cura.CuraApplication.CuraApplication.ResourceTypes.Firmware, hex_file.format(baudrate=baudrate))
+        except FileNotFoundError:
+            Logger.log("w", "Firmware file %s not found.", hex_file)
+            return ""
 
 ## private:
 global_stack_mime = MimeType(

cura/Settings/MachineManager.py

@@ -1,9 +1,10 @@
 # Copyright (c) 2018 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
 
-import collections
 import time
-from typing import Any, Callable, List, Dict, TYPE_CHECKING, Optional, cast
+import re
+import unicodedata
+from typing import Any, List, Dict, TYPE_CHECKING, Optional, cast
 
 from UM.ConfigurationErrorMessage import ConfigurationErrorMessage
 from UM.Scene.Iterator.DepthFirstIterator import DepthFirstIterator
@@ -20,15 +21,17 @@ from UM.Message import Message
 from UM.Settings.SettingFunction import SettingFunction
 from UM.Signal import postponeSignals, CompressTechnique
 
-import cura.CuraApplication
 from cura.Machines.QualityManager import getMachineDefinitionIDForQualitySearch
-from cura.PrinterOutputDevice import PrinterOutputDevice
+from cura.PrinterOutputDevice import PrinterOutputDevice, ConnectionType
 from cura.PrinterOutput.ConfigurationModel import ConfigurationModel
 from cura.PrinterOutput.ExtruderConfigurationModel import ExtruderConfigurationModel
 from cura.PrinterOutput.MaterialOutputModel import MaterialOutputModel
 from cura.Settings.CuraContainerRegistry import CuraContainerRegistry
 from cura.Settings.ExtruderManager import ExtruderManager
 from cura.Settings.ExtruderStack import ExtruderStack
+from cura.Settings.cura_empty_instance_containers import (empty_definition_changes_container, empty_variant_container,
+                                                          empty_material_container, empty_quality_container,
+                                                          empty_quality_changes_container)
 
 from .CuraStackBuilder import CuraStackBuilder
 
@@ -36,6 +39,7 @@ from UM.i18n import i18nCatalog
 catalog = i18nCatalog("cura")
 
 if TYPE_CHECKING:
+    from cura.CuraApplication import CuraApplication
     from cura.Settings.CuraContainerStack import CuraContainerStack
     from cura.Settings.GlobalStack import GlobalStack
     from cura.Machines.MaterialManager import MaterialManager
@@ -47,7 +51,7 @@ if TYPE_CHECKING:
 
 
 class MachineManager(QObject):
-    def __init__(self, parent: QObject = None) -> None:
+    def __init__(self, application: "CuraApplication", parent: Optional["QObject"] = None) -> None:
         super().__init__(parent)
 
         self._active_container_stack = None     # type: Optional[ExtruderStack]
@@ -59,18 +63,17 @@ class MachineManager(QObject):
 
         self._default_extruder_position = "0"  # to be updated when extruders are switched on and off
 
-        self.machine_extruder_material_update_dict = collections.defaultdict(list) #type: Dict[str, List[Callable[[], None]]]
-
-        self._instance_container_timer = QTimer() #type: QTimer
+        self._instance_container_timer = QTimer()  # type: QTimer
         self._instance_container_timer.setInterval(250)
         self._instance_container_timer.setSingleShot(True)
         self._instance_container_timer.timeout.connect(self.__emitChangedSignals)
 
-        self._application = cura.CuraApplication.CuraApplication.getInstance() #type: cura.CuraApplication.CuraApplication
+        self._application = application
+        self._container_registry = self._application.getContainerRegistry()
         self._application.globalContainerStackChanged.connect(self._onGlobalContainerChanged)
-        self._application.getContainerRegistry().containerLoadComplete.connect(self._onContainersChanged)
+        self._container_registry.containerLoadComplete.connect(self._onContainersChanged)
 
-        ##  When the global container is changed, active material probably needs to be updated.
+        #  When the global container is changed, active material probably needs to be updated.
         self.globalContainerChanged.connect(self.activeMaterialChanged)
         self.globalContainerChanged.connect(self.activeVariantChanged)
         self.globalContainerChanged.connect(self.activeQualityChanged)
@@ -80,21 +83,16 @@ class MachineManager(QObject):
 
         self._stacks_have_errors = None  # type: Optional[bool]
 
-        self._empty_container = CuraContainerRegistry.getInstance().getEmptyInstanceContainer() #type: InstanceContainer
-        self._empty_definition_changes_container = CuraContainerRegistry.getInstance().findContainers(id = "empty_definition_changes")[0] #type: InstanceContainer
-        self._empty_variant_container = CuraContainerRegistry.getInstance().findContainers(id = "empty_variant")[0] #type: InstanceContainer
-        self._empty_material_container = CuraContainerRegistry.getInstance().findContainers(id = "empty_material")[0] #type: InstanceContainer
-        self._empty_quality_container = CuraContainerRegistry.getInstance().findContainers(id = "empty_quality")[0] #type: InstanceContainer
-        self._empty_quality_changes_container = CuraContainerRegistry.getInstance().findContainers(id = "empty_quality_changes")[0] #type: InstanceContainer
-
         self._onGlobalContainerChanged()
 
-        ExtruderManager.getInstance().activeExtruderChanged.connect(self._onActiveExtruderStackChanged)
+        extruder_manager = self._application.getExtruderManager()
+
+        extruder_manager.activeExtruderChanged.connect(self._onActiveExtruderStackChanged)
         self._onActiveExtruderStackChanged()
 
-        ExtruderManager.getInstance().activeExtruderChanged.connect(self.activeMaterialChanged)
-        ExtruderManager.getInstance().activeExtruderChanged.connect(self.activeVariantChanged)
-        ExtruderManager.getInstance().activeExtruderChanged.connect(self.activeQualityChanged)
+        extruder_manager.activeExtruderChanged.connect(self.activeMaterialChanged)
+        extruder_manager.activeExtruderChanged.connect(self.activeVariantChanged)
+        extruder_manager.activeExtruderChanged.connect(self.activeQualityChanged)
 
         self.globalContainerChanged.connect(self.activeStackChanged)
         self.globalValueChanged.connect(self.activeStackValueChanged)
@@ -116,17 +114,13 @@ class MachineManager(QObject):
 
         self._application.callLater(self.setInitialActiveMachine)
 
-        self._material_incompatible_message = Message(catalog.i18nc("@info:status",
-                                                "The selected material is incompatible with the selected machine or configuration."),
-                                                title = catalog.i18nc("@info:title", "Incompatible Material")) #type: Message
-
-        containers = CuraContainerRegistry.getInstance().findInstanceContainers(id = self.activeMaterialId) #type: List[InstanceContainer]
+        containers = CuraContainerRegistry.getInstance().findInstanceContainers(id = self.activeMaterialId)  # type: List[InstanceContainer]
         if containers:
             containers[0].nameChanged.connect(self._onMaterialNameChanged)
 
-        self._material_manager = self._application.getMaterialManager() #type: MaterialManager
-        self._variant_manager = self._application.getVariantManager() #type: VariantManager
-        self._quality_manager = self._application.getQualityManager() #type: QualityManager
+        self._material_manager = self._application.getMaterialManager()  # type: MaterialManager
+        self._variant_manager = self._application.getVariantManager()  # type: VariantManager
+        self._quality_manager = self._application.getQualityManager()  # type: QualityManager
 
         # When the materials lookup table gets updated, it can mean that a material has its name changed, which should
         # be reflected on the GUI. This signal emission makes sure that it happens.
@@ -159,7 +153,7 @@ class MachineManager(QObject):
     blurSettings = pyqtSignal()  # Emitted to force fields in the advanced sidebar to un-focus, so they update properly
 
     outputDevicesChanged = pyqtSignal()
-    currentConfigurationChanged = pyqtSignal() # Emitted every time the current configurations of the machine changes
+    currentConfigurationChanged = pyqtSignal()  # Emitted every time the current configurations of the machine changes
     printerConnectedStatusChanged = pyqtSignal() # Emitted every time the active machine change or the outputdevices change
 
     rootMaterialChanged = pyqtSignal()
@@ -177,6 +171,7 @@ class MachineManager(QObject):
                 self._printer_output_devices.append(printer_output_device)
 
         self.outputDevicesChanged.emit()
+        self.printerConnectedStatusChanged.emit()
 
     @pyqtProperty(QObject, notify = currentConfigurationChanged)
     def currentConfiguration(self) -> ConfigurationModel:
@@ -192,19 +187,21 @@ class MachineManager(QObject):
         for extruder in self._global_container_stack.extruders.values():
             extruder_configuration = ExtruderConfigurationModel()
             # For compare just the GUID is needed at this moment
-            mat_type = extruder.material.getMetaDataEntry("material") if extruder.material != self._empty_material_container else None
-            mat_guid = extruder.material.getMetaDataEntry("GUID") if extruder.material != self._empty_material_container else None
-            mat_color = extruder.material.getMetaDataEntry("color_name") if extruder.material != self._empty_material_container else None
-            mat_brand = extruder.material.getMetaDataEntry("brand") if extruder.material != self._empty_material_container else None
-            mat_name = extruder.material.getMetaDataEntry("name") if extruder.material != self._empty_material_container else None
+            mat_type = extruder.material.getMetaDataEntry("material") if extruder.material != empty_material_container else None
+            mat_guid = extruder.material.getMetaDataEntry("GUID") if extruder.material != empty_material_container else None
+            mat_color = extruder.material.getMetaDataEntry("color_name") if extruder.material != empty_material_container else None
+            mat_brand = extruder.material.getMetaDataEntry("brand") if extruder.material != empty_material_container else None
+            mat_name = extruder.material.getMetaDataEntry("name") if extruder.material != empty_material_container else None
             material_model = MaterialOutputModel(mat_guid, mat_type, mat_color, mat_brand, mat_name)
 
             extruder_configuration.position = int(extruder.getMetaDataEntry("position"))
             extruder_configuration.material = material_model
-            extruder_configuration.hotendID = extruder.variant.getName() if extruder.variant != self._empty_variant_container else None
+            extruder_configuration.hotendID = extruder.variant.getName() if extruder.variant != empty_variant_container else None
             self._current_printer_configuration.extruderConfigurations.append(extruder_configuration)
 
-        self._current_printer_configuration.buildplateConfiguration = self._global_container_stack.getProperty("machine_buildplate_type", "value") if self._global_container_stack.variant != self._empty_variant_container else None
+        # An empty build plate configuration from the network printer is presented as an empty string, so use "" for an
+        # empty build plate.
+        self._current_printer_configuration.buildplateConfiguration = self._global_container_stack.getProperty("machine_buildplate_type", "value") if self._global_container_stack.variant != empty_variant_container else ""
         self.currentConfigurationChanged.emit()
 
     @pyqtSlot(QObject, result = bool)
@@ -248,7 +245,7 @@ class MachineManager(QObject):
             self.updateNumberExtrudersEnabled()
         self.globalContainerChanged.emit()
 
-        # after switching the global stack we reconnect all the signals and set the variant and material references
+        # After switching the global stack we reconnect all the signals and set the variant and material references
         if self._global_container_stack:
             self._application.getPreferences().setValue("cura/active_machine", self._global_container_stack.getId())
 
@@ -258,44 +255,33 @@ class MachineManager(QObject):
 
             # Global stack can have only a variant if it is a buildplate
             global_variant = self._global_container_stack.variant
-            if global_variant != self._empty_variant_container:
+            if global_variant != empty_variant_container:
                 if global_variant.getMetaDataEntry("hardware_type") != "buildplate":
-                    self._global_container_stack.setVariant(self._empty_variant_container)
+                    self._global_container_stack.setVariant(empty_variant_container)
 
-            # set the global material to empty as we now use the extruder stack at all times - CURA-4482
+            # Set the global material to empty as we now use the extruder stack at all times - CURA-4482
             global_material = self._global_container_stack.material
-            if global_material != self._empty_material_container:
-                self._global_container_stack.setMaterial(self._empty_material_container)
+            if global_material != empty_material_container:
+                self._global_container_stack.setMaterial(empty_material_container)
 
             # Listen for changes on all extruder stacks
             for extruder_stack in ExtruderManager.getInstance().getActiveExtruderStacks():
                 extruder_stack.propertyChanged.connect(self._onPropertyChanged)
                 extruder_stack.containersChanged.connect(self._onContainersChanged)
 
-            if self._global_container_stack.getId() in self.machine_extruder_material_update_dict:
-                for func in self.machine_extruder_material_update_dict[self._global_container_stack.getId()]:
-                    self._application.callLater(func)
-                del self.machine_extruder_material_update_dict[self._global_container_stack.getId()]
-
         self.activeQualityGroupChanged.emit()
 
     def _onActiveExtruderStackChanged(self) -> None:
         self.blurSettings.emit()  # Ensure no-one has focus.
-        old_active_container_stack = self._active_container_stack
-
         self._active_container_stack = ExtruderManager.getInstance().getActiveExtruderStack()
 
-        if old_active_container_stack != self._active_container_stack:
-            # Many methods and properties related to the active quality actually depend
-            # on _active_container_stack. If it changes, then the properties change.
-            self.activeQualityChanged.emit()
-
     def __emitChangedSignals(self) -> None:
         self.activeQualityChanged.emit()
         self.activeVariantChanged.emit()
         self.activeMaterialChanged.emit()
 
         self.rootMaterialChanged.emit()
+        self.numberExtrudersEnabledChanged.emit()
 
     def _onContainersChanged(self, container: ContainerInterface) -> None:
         self._instance_container_timer.start()
@@ -367,15 +353,21 @@ class MachineManager(QObject):
             return
 
         global_stack = containers[0]
+
+        # Make sure that the default machine actions for this machine have been added
+        self._application.getMachineActionManager().addDefaultMachineActions(global_stack)
+
+        ExtruderManager.getInstance()._fixSingleExtrusionMachineExtruderDefinition(global_stack)
         if not global_stack.isValid():
             # Mark global stack as invalid
             ConfigurationErrorMessage.getInstance().addFaultyContainers(global_stack.getId())
             return  # We're done here
         ExtruderManager.getInstance().setActiveExtruderIndex(0)  # Switch to first extruder
+
         self._global_container_stack = global_stack
         self._application.setGlobalContainerStack(global_stack)
         ExtruderManager.getInstance()._globalContainerStackChanged()
-        self._initMachineState(containers[0])
+        self._initMachineState(global_stack)
         self._onGlobalContainerChanged()
 
         self.__emitChangedSignals()
@@ -385,7 +377,9 @@ class MachineManager(QObject):
     #   \param definition_id \type{str} definition id that needs to look for
     #   \param metadata_filter \type{dict} list of metadata keys and values used for filtering
     @staticmethod
-    def getMachine(definition_id: str, metadata_filter: Dict[str, str] = None) -> Optional["GlobalStack"]:
+    def getMachine(definition_id: str, metadata_filter: Optional[Dict[str, str]] = None) -> Optional["GlobalStack"]:
+        if metadata_filter is None:
+            metadata_filter = {}
         machines = CuraContainerRegistry.getInstance().findContainerStacks(type = "machine", **metadata_filter)
         for machine in machines:
             if machine.definition.getId() == definition_id:
@@ -412,8 +406,8 @@ class MachineManager(QObject):
 
         # Not a very pretty solution, but the extruder manager doesn't really know how many extruders there are
         machine_extruder_count = self._global_container_stack.getProperty("machine_extruder_count", "value")
-        extruder_stacks = ExtruderManager.getInstance().getMachineExtruders(self._global_container_stack.getId())
-        count = 1  # we start with the global stack
+        extruder_stacks = ExtruderManager.getInstance().getActiveExtruderStacks()
+        count = 1  # We start with the global stack
         for stack in extruder_stacks:
             md = stack.getMetaData()
             if "position" in md and int(md["position"]) >= machine_extruder_count:
@@ -432,12 +426,12 @@ class MachineManager(QObject):
         if not self._global_container_stack:
             return False
 
-        if self._global_container_stack.getTop().findInstances():
+        if self._global_container_stack.getTop().getNumInstances() != 0:
             return True
 
-        stacks = list(ExtruderManager.getInstance().getMachineExtruders(self._global_container_stack.getId()))
+        stacks = ExtruderManager.getInstance().getActiveExtruderStacks()
         for stack in stacks:
-            if stack.getTop().findInstances():
+            if stack.getTop().getNumInstances() != 0:
                 return True
 
         return False
@@ -447,10 +441,10 @@ class MachineManager(QObject):
         if not self._global_container_stack:
             return 0
         num_user_settings = 0
-        num_user_settings += len(self._global_container_stack.getTop().findInstances())
-        stacks = list(ExtruderManager.getInstance().getMachineExtruders(self._global_container_stack.getId()))
+        num_user_settings += self._global_container_stack.getTop().getNumInstances()
+        stacks = self._global_container_stack.extruderList
         for stack in stacks:
-            num_user_settings += len(stack.getTop().findInstances())
+            num_user_settings += stack.getTop().getNumInstances()
         return num_user_settings
 
     ##  Delete a user setting from the global stack and all extruder stacks.
@@ -473,7 +467,7 @@ class MachineManager(QObject):
             stack = ExtruderManager.getInstance().getActiveExtruderStack()
             stacks = [stack]
         else:
-            stacks = ExtruderManager.getInstance().getMachineExtruders(self._global_container_stack.getId())
+            stacks = ExtruderManager.getInstance().getActiveExtruderStacks()
 
         for stack in stacks:
             if stack is not None:
@@ -500,7 +494,7 @@ class MachineManager(QObject):
     @pyqtProperty(str, notify = globalContainerChanged)
     def activeMachineName(self) -> str:
         if self._global_container_stack:
-            return self._global_container_stack.getName()
+            return self._global_container_stack.getMetaDataEntry("group_name", self._global_container_stack.getName())
         return ""
 
     @pyqtProperty(str, notify = globalContainerChanged)
@@ -509,11 +503,57 @@ class MachineManager(QObject):
             return self._global_container_stack.getId()
         return ""
 
+    @pyqtProperty(str, notify = globalContainerChanged)
+    def activeMachineFirmwareVersion(self) -> str:
+        if not self._printer_output_devices:
+            return ""
+        return self._printer_output_devices[0].firmwareVersion
+
+    @pyqtProperty(str, notify = globalContainerChanged)
+    def activeMachineAddress(self) -> str:
+        if not self._printer_output_devices:
+            return ""
+        return self._printer_output_devices[0].address
+
     @pyqtProperty(bool, notify = printerConnectedStatusChanged)
-    def printerConnected(self):
+    def printerConnected(self) -> bool:
         return bool(self._printer_output_devices)
 
-    @pyqtProperty(str, notify = printerConnectedStatusChanged)
+    @pyqtProperty(bool, notify = printerConnectedStatusChanged)
+    def activeMachineHasRemoteConnection(self) -> bool:
+        if self._global_container_stack:
+            has_remote_connection = False
+
+            for connection_type in self._global_container_stack.configuredConnectionTypes:
+                has_remote_connection |= connection_type in [ConnectionType.NetworkConnection.value,
+                                                             ConnectionType.CloudConnection.value]
+            return has_remote_connection
+        return False
+
+    @pyqtProperty("QVariantList", notify=globalContainerChanged)
+    def activeMachineConfiguredConnectionTypes(self):
+        if self._global_container_stack:
+            return self._global_container_stack.configuredConnectionTypes
+        return []
+
+    @pyqtProperty(bool, notify = printerConnectedStatusChanged)
+    def activeMachineIsGroup(self) -> bool:
+        return bool(self._printer_output_devices) and len(self._printer_output_devices[0].printers) > 1
+
+    @pyqtProperty(bool, notify = printerConnectedStatusChanged)
+    def activeMachineHasNetworkConnection(self) -> bool:
+        # A network connection is only available if any output device is actually a network connected device.
+        return any(d.connectionType == ConnectionType.NetworkConnection for d in self._printer_output_devices)
+
+    @pyqtProperty(bool, notify = printerConnectedStatusChanged)
+    def activeMachineHasCloudConnection(self) -> bool:
+        # A cloud connection is only available if any output device actually is a cloud connected device.
+        return any(d.connectionType == ConnectionType.CloudConnection for d in self._printer_output_devices)
+    
+    @pyqtProperty(bool, notify = printerConnectedStatusChanged)
+    def activeMachineIsUsingCloudConnection(self) -> bool:
+        return self.activeMachineHasCloudConnection and not self.activeMachineHasNetworkConnection
+
     def activeMachineNetworkKey(self) -> str:
         if self._global_container_stack:
             return self._global_container_stack.getMetaDataEntry("um_network_key", "")
@@ -522,7 +562,7 @@ class MachineManager(QObject):
     @pyqtProperty(str, notify = printerConnectedStatusChanged)
     def activeMachineNetworkGroupName(self) -> str:
         if self._global_container_stack:
-            return self._global_container_stack.getMetaDataEntry("connect_group_name", "")
+            return self._global_container_stack.getMetaDataEntry("group_name", "")
         return ""
 
     @pyqtProperty(QObject, notify = globalContainerChanged)
@@ -590,7 +630,7 @@ class MachineManager(QObject):
     def globalVariantName(self) -> str:
         if self._global_container_stack:
             variant = self._global_container_stack.variant
-            if variant and not isinstance(variant, type(self._empty_variant_container)):
+            if variant and not isinstance(variant, type(empty_variant_container)):
                 return variant.getName()
         return ""
 
@@ -610,6 +650,14 @@ class MachineManager(QObject):
                 is_supported = self._current_quality_group.is_available
         return is_supported
 
+    @pyqtProperty(bool, notify = activeQualityGroupChanged)
+    def isActiveQualityExperimental(self) -> bool:
+        is_experimental = False
+        if self._global_container_stack:
+            if self._current_quality_group:
+                is_experimental = self._current_quality_group.is_experimental
+        return is_experimental
+
     ##  Returns whether there is anything unsupported in the current set-up.
     #
     #   The current set-up signifies the global stack and all extruder stacks,
@@ -638,9 +686,9 @@ class MachineManager(QObject):
         if self._active_container_stack is None or self._global_container_stack is None:
             return
         new_value = self._active_container_stack.getProperty(key, "value")
-        extruder_stacks = [stack for stack in ExtruderManager.getInstance().getMachineExtruders(self._global_container_stack.getId())]
+        extruder_stacks = [stack for stack in ExtruderManager.getInstance().getActiveExtruderStacks()]
 
-        # check in which stack the value has to be replaced
+        # Check in which stack the value has to be replaced
         for extruder_stack in extruder_stacks:
             if extruder_stack != self._active_container_stack and extruder_stack.getProperty(key, "value") != new_value:
                 extruder_stack.userChanges.setProperty(key, "value", new_value)  # TODO: nested property access, should be improved
@@ -656,7 +704,7 @@ class MachineManager(QObject):
                 for key in self._active_container_stack.userChanges.getAllKeys():
                     new_value = self._active_container_stack.getProperty(key, "value")
 
-                    # check if the value has to be replaced
+                    # Check if the value has to be replaced
                     extruder_stack.userChanges.setProperty(key, "value", new_value)
 
     @pyqtProperty(str, notify = activeVariantChanged)
@@ -725,7 +773,7 @@ class MachineManager(QObject):
         # If the machine that is being removed is the currently active machine, set another machine as the active machine.
         activate_new_machine = (self._global_container_stack and self._global_container_stack.getId() == machine_id)
 
-        # activate a new machine before removing a machine because this is safer
+        # Activate a new machine before removing a machine because this is safer
         if activate_new_machine:
             machine_stacks = CuraContainerRegistry.getInstance().findContainerStacksMetadata(type = "machine")
             other_machine_stacks = [s for s in machine_stacks if s["id"] != machine_id]
@@ -733,7 +781,7 @@ class MachineManager(QObject):
                 self.setActiveMachine(other_machine_stacks[0]["id"])
 
         metadata = CuraContainerRegistry.getInstance().findContainerStacksMetadata(id = machine_id)[0]
-        network_key = metadata["um_network_key"] if "um_network_key" in metadata else None
+        network_key = metadata.get("um_network_key", None)
         ExtruderManager.getInstance().removeMachineExtruders(machine_id)
         containers = CuraContainerRegistry.getInstance().findInstanceContainersMetadata(type = "user", machine = machine_id)
         for container in containers:
@@ -778,7 +826,7 @@ class MachineManager(QObject):
             if not stack.isEnabled:
                 continue
             material_container = stack.material
-            if material_container == self._empty_material_container:
+            if material_container == empty_material_container:
                 continue
             if material_container.getMetaDataEntry("buildplate_compatible"):
                 buildplate_compatible = buildplate_compatible and material_container.getMetaDataEntry("buildplate_compatible")[self.activeVariantBuildplateName]
@@ -800,7 +848,7 @@ class MachineManager(QObject):
         extruder_stacks = self._global_container_stack.extruders.values()
         for stack in extruder_stacks:
             material_container = stack.material
-            if material_container == self._empty_material_container:
+            if material_container == empty_material_container:
                 continue
             buildplate_compatible = material_container.getMetaDataEntry("buildplate_compatible")[self.activeVariantBuildplateName] if material_container.getMetaDataEntry("buildplate_compatible") else True
             buildplate_usable = material_container.getMetaDataEntry("buildplate_recommended")[self.activeVariantBuildplateName] if material_container.getMetaDataEntry("buildplate_recommended") else True
@@ -858,7 +906,7 @@ class MachineManager(QObject):
             caution_message = Message(catalog.i18nc(
                 "@info:generic",
                 "Settings have been changed to match the current availability of extruders: [%s]" % ", ".join(add_user_changes)),
-                lifetime=0,
+                lifetime = 0,
                 title = catalog.i18nc("@info:title", "Settings updated"))
             caution_message.show()
 
@@ -870,7 +918,7 @@ class MachineManager(QObject):
         extruder_manager = self._application.getExtruderManager()
 
         definition_changes_container = self._global_container_stack.definitionChanges
-        if not self._global_container_stack or definition_changes_container == self._empty_definition_changes_container:
+        if not self._global_container_stack or definition_changes_container == empty_definition_changes_container:
             return
 
         previous_extruder_count = self._global_container_stack.getProperty("machine_extruder_count", "value")
@@ -890,7 +938,11 @@ class MachineManager(QObject):
                 extruder_nr = node.callDecoration("getActiveExtruderPosition")
 
                 if extruder_nr is not None and int(extruder_nr) > extruder_count - 1:
-                    node.callDecoration("setActiveExtruder", extruder_manager.getExtruderStack(extruder_count - 1).getId())
+                    extruder = extruder_manager.getExtruderStack(extruder_count - 1)
+                    if extruder is not None:
+                        node.callDecoration("setActiveExtruder", extruder.getId())
+                    else:
+                        Logger.log("w", "Could not find extruder to set active.")
 
         # Make sure one of the extruder stacks is active
         extruder_manager.setActiveExtruderIndex(0)
@@ -899,21 +951,18 @@ class MachineManager(QObject):
         # After CURA-4482 this should not be the case anymore, but we still want to support older project files.
         global_user_container = self._global_container_stack.userChanges
 
-        # Make sure extruder_stacks exists
-        extruder_stacks = [] #type: List[ExtruderStack]
-
-        if previous_extruder_count == 1:
-            extruder_stacks = ExtruderManager.getInstance().getActiveExtruderStacks()
-            global_user_container = self._global_container_stack.userChanges
-
         for setting_instance in global_user_container.findInstances():
             setting_key = setting_instance.definition.key
             settable_per_extruder = self._global_container_stack.getProperty(setting_key, "settable_per_extruder")
 
             if settable_per_extruder:
                 limit_to_extruder = int(self._global_container_stack.getProperty(setting_key, "limit_to_extruder"))
-                extruder_stack = extruder_stacks[max(0, limit_to_extruder)]
-                extruder_stack.userChanges.setProperty(setting_key, "value", global_user_container.getProperty(setting_key, "value"))
+                extruder_position = max(0, limit_to_extruder)
+                extruder_stack = self.getExtruder(extruder_position)
+                if extruder_stack:
+                    extruder_stack.userChanges.setProperty(setting_key, "value", global_user_container.getProperty(setting_key, "value"))
+                else:
+                    Logger.log("e", "Unable to find extruder on position %s", extruder_position)
                 global_user_container.removeInstance(setting_key)
 
         # Signal that the global stack has changed
@@ -922,10 +971,9 @@ class MachineManager(QObject):
 
     @pyqtSlot(int, result = QObject)
     def getExtruder(self, position: int) -> Optional[ExtruderStack]:
-        extruder = None
         if self._global_container_stack:
-            extruder = self._global_container_stack.extruders.get(str(position))
-        return extruder
+            return self._global_container_stack.extruders.get(str(position))
+        return None
 
     def updateDefaultExtruder(self) -> None:
         if self._global_container_stack is None:
@@ -991,12 +1039,12 @@ class MachineManager(QObject):
         if not enabled and position == ExtruderManager.getInstance().activeExtruderIndex:
             ExtruderManager.getInstance().setActiveExtruderIndex(int(self._default_extruder_position))
 
-        # ensure that the quality profile is compatible with current combination, or choose a compatible one if available
+        # Ensure that the quality profile is compatible with current combination, or choose a compatible one if available
         self._updateQualityWithMaterial()
         self.extruderChanged.emit()
-        # update material compatibility color
+        # Update material compatibility color
         self.activeQualityGroupChanged.emit()
-        # update items in SettingExtruder
+        # Update items in SettingExtruder
         ExtruderManager.getInstance().extrudersChanged.emit(self._global_container_stack.getId())
         # Make sure the front end reflects changes
         self.forceUpdateAllSettings()
@@ -1065,12 +1113,11 @@ class MachineManager(QObject):
         for stack in active_stacks:
             variant_container = stack.variant
             position = stack.getMetaDataEntry("position")
-            if variant_container and variant_container != self._empty_variant_container:
+            if variant_container and variant_container != empty_variant_container:
                 result[position] = variant_container.getName()
 
         return result
 
-    #
     # Sets all quality and quality_changes containers to empty_quality and empty_quality_changes containers
     # for all stacks in the currently active machine.
     #
@@ -1079,11 +1126,11 @@ class MachineManager(QObject):
             return
         self._current_quality_group = None
         self._current_quality_changes_group = None
-        self._global_container_stack.quality = self._empty_quality_container
-        self._global_container_stack.qualityChanges = self._empty_quality_changes_container
+        self._global_container_stack.quality = empty_quality_container
+        self._global_container_stack.qualityChanges = empty_quality_changes_container
         for extruder in self._global_container_stack.extruders.values():
-            extruder.quality = self._empty_quality_container
-            extruder.qualityChanges = self._empty_quality_changes_container
+            extruder.quality = empty_quality_container
+            extruder.qualityChanges = empty_quality_changes_container
 
         self.activeQualityGroupChanged.emit()
         self.activeQualityChangesGroupChanged.emit()
@@ -1108,13 +1155,13 @@ class MachineManager(QObject):
         # Set quality and quality_changes for the GlobalStack
         self._global_container_stack.quality = quality_group.node_for_global.getContainer()
         if empty_quality_changes:
-            self._global_container_stack.qualityChanges = self._empty_quality_changes_container
+            self._global_container_stack.qualityChanges = empty_quality_changes_container
 
         # Set quality and quality_changes for each ExtruderStack
         for position, node in quality_group.nodes_for_extruders.items():
             self._global_container_stack.extruders[str(position)].quality = node.getContainer()
             if empty_quality_changes:
-                self._global_container_stack.extruders[str(position)].qualityChanges = self._empty_quality_changes_container
+                self._global_container_stack.extruders[str(position)].qualityChanges = empty_quality_changes_container
 
         self.activeQualityGroupChanged.emit()
         self.activeQualityChangesGroupChanged.emit()
@@ -1129,7 +1176,7 @@ class MachineManager(QObject):
 
     def _setQualityChangesGroup(self, quality_changes_group: "QualityChangesGroup") -> None:
         if self._global_container_stack is None:
-            return #Can't change that.
+            return  # Can't change that.
         quality_type = quality_changes_group.quality_type
         # A custom quality can be created based on "not supported".
         # In that case, do not set quality containers to empty.
@@ -1140,8 +1187,8 @@ class MachineManager(QObject):
             if quality_group is None:
                 self._fixQualityChangesGroupToNotSupported(quality_changes_group)
 
-        quality_changes_container = self._empty_quality_changes_container
-        quality_container = self._empty_quality_container
+        quality_changes_container = empty_quality_changes_container
+        quality_container = empty_quality_container  # type: Optional[InstanceContainer]
         if quality_changes_group.node_for_global and quality_changes_group.node_for_global.getContainer():
             quality_changes_container = cast(InstanceContainer, quality_changes_group.node_for_global.getContainer())
         if quality_group is not None and quality_group.node_for_global and quality_group.node_for_global.getContainer():
@@ -1156,8 +1203,8 @@ class MachineManager(QObject):
             if quality_group is not None:
                 quality_node = quality_group.nodes_for_extruders.get(position)
 
-            quality_changes_container = self._empty_quality_changes_container
-            quality_container = self._empty_quality_container
+            quality_changes_container = empty_quality_changes_container
+            quality_container = empty_quality_container
             if quality_changes_node and quality_changes_node.getContainer():
                 quality_changes_container = cast(InstanceContainer, quality_changes_node.getContainer())
             if quality_node and quality_node.getContainer():
@@ -1191,7 +1238,7 @@ class MachineManager(QObject):
             self._global_container_stack.extruders[position].material = container_node.getContainer()
             root_material_id = container_node.getMetaDataEntry("base_file", None)
         else:
-            self._global_container_stack.extruders[position].material = self._empty_material_container
+            self._global_container_stack.extruders[position].material = empty_material_container
             root_material_id = None
         # The _current_root_material_id is used in the MaterialMenu to see which material is selected
         if root_material_id != self._current_root_material_id[position]:
@@ -1199,7 +1246,7 @@ class MachineManager(QObject):
             self.rootMaterialChanged.emit()
 
     def activeMaterialsCompatible(self) -> bool:
-        # check material - variant compatibility
+        # Check material - variant compatibility
         if self._global_container_stack is not None:
             if Util.parseBool(self._global_container_stack.getMetaDataEntry("has_materials", False)):
                 for position, extruder in self._global_container_stack.extruders.items():
@@ -1266,14 +1313,10 @@ class MachineManager(QObject):
 
             current_material_base_name = extruder.material.getMetaDataEntry("base_file")
             current_nozzle_name = None
-            if extruder.variant.getId() != self._empty_variant_container.getId():
+            if extruder.variant.getId() != empty_variant_container.getId():
                 current_nozzle_name = extruder.variant.getMetaDataEntry("name")
 
-            from UM.Settings.Interfaces import PropertyEvaluationContext
-            from cura.Settings.CuraContainerStack import _ContainerIndexes
-            context = PropertyEvaluationContext(extruder)
-            context.context["evaluate_from_container_index"] = _ContainerIndexes.DefinitionChanges
-            material_diameter = extruder.getProperty("material_diameter", "value", context)
+            material_diameter = extruder.getCompatibleMaterialDiameter()
             candidate_materials = self._material_manager.getAvailableMaterials(
                 self._global_container_stack.definition,
                 current_nozzle_name,
@@ -1304,17 +1347,18 @@ class MachineManager(QObject):
         # Get the definition id corresponding to this machine name
         machine_definition_id = CuraContainerRegistry.getInstance().findDefinitionContainers(name = machine_name)[0].getId()
         # Try to find a machine with the same network key
-        new_machine = self.getMachine(machine_definition_id, metadata_filter = {"um_network_key": self.activeMachineNetworkKey})
+        new_machine = self.getMachine(machine_definition_id, metadata_filter = {"um_network_key": self.activeMachineNetworkKey()})
         # If there is no machine, then create a new one and set it to the non-hidden instance
         if not new_machine:
             new_machine = CuraStackBuilder.createMachine(machine_definition_id + "_sync", machine_definition_id)
             if not new_machine:
                 return
-            new_machine.setMetaDataEntry("um_network_key", self.activeMachineNetworkKey)
-            new_machine.setMetaDataEntry("connect_group_name", self.activeMachineNetworkGroupName)
+            new_machine.setMetaDataEntry("um_network_key", self.activeMachineNetworkKey())
+            new_machine.setMetaDataEntry("group_name", self.activeMachineNetworkGroupName)
             new_machine.setMetaDataEntry("hidden", False)
+            new_machine.setMetaDataEntry("connection_type", self._global_container_stack.getMetaDataEntry("connection_type"))
         else:
-            Logger.log("i", "Found a %s with the key %s. Let's use it!", machine_name, self.activeMachineNetworkKey)
+            Logger.log("i", "Found a %s with the key %s. Let's use it!", machine_name, self.activeMachineNetworkKey())
             new_machine.setMetaDataEntry("hidden", False)
 
         # Set the current printer instance to hidden (the metadata entry must exist)
@@ -1329,36 +1373,83 @@ class MachineManager(QObject):
         self.blurSettings.emit()
         with postponeSignals(*self._getContainerChangedSignals(), compress = CompressTechnique.CompressPerParameterValue):
             self.switchPrinterType(configuration.printerType)
+
+            disabled_used_extruder_position_set = set()
+            extruders_to_disable = set()
+
+            # If an extruder that's currently used to print a model gets disabled due to the syncing, we need to show
+            # a message explaining why.
+            need_to_show_message = False
+
+            for extruder_configuration in configuration.extruderConfigurations:
+                extruder_has_hotend = extruder_configuration.hotendID != ""
+                extruder_has_material = extruder_configuration.material.guid != ""
+
+                # If the machine doesn't have a hotend or material, disable this extruder
+                if not extruder_has_hotend or not extruder_has_material:
+                    extruders_to_disable.add(extruder_configuration.position)
+
+            # If there's no material and/or nozzle on the printer, enable the first extruder and disable the rest.
+            if len(extruders_to_disable) == len(self._global_container_stack.extruders):
+                extruders_to_disable.remove(min(extruders_to_disable))
+
             for extruder_configuration in configuration.extruderConfigurations:
                 position = str(extruder_configuration.position)
-                variant_container_node = self._variant_manager.getVariantNode(self._global_container_stack.definition.getId(), extruder_configuration.hotendID)
-                material_container_node = self._material_manager.getMaterialNodeByType(self._global_container_stack,
-                                                                                       position,
-                                                                                       extruder_configuration.hotendID,
-                                                                                       configuration.buildplateConfiguration,
-                                                                                       extruder_configuration.material.guid)
 
-                if variant_container_node:
-                    self._setVariantNode(position, variant_container_node)
-                else:
-                    self._global_container_stack.extruders[position].variant = self._empty_variant_container
+                # If the machine doesn't have a hotend or material, disable this extruder
+                if int(position) in extruders_to_disable:
+                    self._global_container_stack.extruders[position].setEnabled(False)
+
+                    need_to_show_message = True
+                    disabled_used_extruder_position_set.add(int(position))
 
-                if material_container_node:
-                    self._setMaterial(position, material_container_node)
                 else:
-                    self._global_container_stack.extruders[position].material = self._empty_material_container
-                self.updateMaterialWithVariant(position)
+                    variant_container_node = self._variant_manager.getVariantNode(self._global_container_stack.definition.getId(),
+                                                                                  extruder_configuration.hotendID)
+                    material_container_node = self._material_manager.getMaterialNodeByType(self._global_container_stack,
+                                                                                           position,
+                                                                                           extruder_configuration.hotendID,
+                                                                                           configuration.buildplateConfiguration,
+                                                                                           extruder_configuration.material.guid)
+                    if variant_container_node:
+                        self._setVariantNode(position, variant_container_node)
+                    else:
+                        self._global_container_stack.extruders[position].variant = empty_variant_container
+
+                    if material_container_node:
+                        self._setMaterial(position, material_container_node)
+                    else:
+                        self._global_container_stack.extruders[position].material = empty_material_container
+                    self._global_container_stack.extruders[position].setEnabled(True)
+                    self.updateMaterialWithVariant(position)
+
+            self.updateNumberExtrudersEnabled()
 
             if configuration.buildplateConfiguration is not None:
                 global_variant_container_node = self._variant_manager.getBuildplateVariantNode(self._global_container_stack.definition.getId(), configuration.buildplateConfiguration)
                 if global_variant_container_node:
                     self._setGlobalVariant(global_variant_container_node)
                 else:
-                    self._global_container_stack.variant = self._empty_variant_container
+                    self._global_container_stack.variant = empty_variant_container
             else:
-                self._global_container_stack.variant = self._empty_variant_container
+                self._global_container_stack.variant = empty_variant_container
             self._updateQualityWithMaterial()
 
+            if need_to_show_message:
+                msg_str = "{extruders} is disabled because there is no material loaded. Please load a material or use custom configurations."
+
+                # Show human-readable extruder names such as "Extruder Left", "Extruder Front" instead of "Extruder 1, 2, 3".
+                extruder_names = []
+                for extruder_position in sorted(disabled_used_extruder_position_set):
+                    extruder_stack = self._global_container_stack.extruders[str(extruder_position)]
+                    extruder_name = extruder_stack.definition.getName()
+                    extruder_names.append(extruder_name)
+                extruders_str = ", ".join(extruder_names)
+                msg_str = msg_str.format(extruders = extruders_str)
+                message = Message(catalog.i18nc("@info:status", msg_str),
+                                  title = catalog.i18nc("@info:title", "Extruder(s) Disabled"))
+                message.show()
+
         # See if we need to show the Discard or Keep changes screen
         if self.hasUserSettings and self._application.getPreferences().getValue("cura/active_mode") == 1:
             self._application.discardOrKeepProfileChanges()
@@ -1374,13 +1465,13 @@ class MachineManager(QObject):
     #   After updating from 3.2 to 3.3 some group names may be temporary. If there is a mismatch in the name of the group
     #   then all the container stacks are updated, both the current and the hidden ones.
     def checkCorrectGroupName(self, device_id: str, group_name: str) -> None:
-        if self._global_container_stack and device_id == self.activeMachineNetworkKey:
-            # Check if the connect_group_name is correct. If not, update all the containers connected to the same printer
+        if self._global_container_stack and device_id == self.activeMachineNetworkKey():
+            # Check if the group_name is correct. If not, update all the containers connected to the same printer
             if self.activeMachineNetworkGroupName != group_name:
-                metadata_filter = {"um_network_key": self.activeMachineNetworkKey}
+                metadata_filter = {"um_network_key": self.activeMachineNetworkKey()}
                 containers = CuraContainerRegistry.getInstance().findContainerStacks(type = "machine", **metadata_filter)
                 for container in containers:
-                    container.setMetaDataEntry("connect_group_name", group_name)
+                    container.setMetaDataEntry("group_name", group_name)
 
     ##  This method checks if there is an instance connected to the given network_key
     def existNetworkInstances(self, network_key: str) -> bool:
@@ -1408,12 +1499,12 @@ class MachineManager(QObject):
         position = str(position)
         extruder_stack = self._global_container_stack.extruders[position]
         nozzle_name = extruder_stack.variant.getName()
-        material_diameter = extruder_stack.approximateMaterialDiameter
+        material_diameter = extruder_stack.getApproximateMaterialDiameter()
         material_node = self._material_manager.getMaterialNode(machine_definition_id, nozzle_name, buildplate_name,
                                                                material_diameter, root_material_id)
         self.setMaterial(position, material_node)
 
-    ##  global_stack: if you want to provide your own global_stack instead of the current active one
+    ##  Global_stack: if you want to provide your own global_stack instead of the current active one
     #   if you update an active machine, special measures have to be taken.
     @pyqtSlot(str, "QVariant")
     def setMaterial(self, position: str, container_node, global_stack: Optional["GlobalStack"] = None) -> None:
@@ -1474,7 +1565,7 @@ class MachineManager(QObject):
             # This is not changing the quality for the active machine !!!!!!!!
             global_stack.quality = quality_group.node_for_global.getContainer()
             for extruder_nr, extruder_stack in global_stack.extruders.items():
-                quality_container = self._empty_quality_container
+                quality_container = empty_quality_container
                 if extruder_nr in quality_group.nodes_for_extruders:
                     container = quality_group.nodes_for_extruders[extruder_nr].getContainer()
                     quality_container = container if container is not None else quality_container
@@ -1516,18 +1607,45 @@ class MachineManager(QObject):
     def activeQualityChangesGroup(self) -> Optional["QualityChangesGroup"]:
         return self._current_quality_changes_group
 
+    @pyqtProperty(bool, notify = activeQualityChangesGroupChanged)
+    def hasCustomQuality(self) -> bool:
+        return self._current_quality_changes_group is not None
+
     @pyqtProperty(str, notify = activeQualityGroupChanged)
     def activeQualityOrQualityChangesName(self) -> str:
-        name = self._empty_quality_container.getName()
+        name = empty_quality_container.getName()
         if self._current_quality_changes_group:
             name = self._current_quality_changes_group.name
         elif self._current_quality_group:
             name = self._current_quality_group.name
         return name
 
+    @pyqtProperty(bool, notify = activeQualityGroupChanged)
+    def hasNotSupportedQuality(self) -> bool:
+        return self._current_quality_group is None and self._current_quality_changes_group is None
+
     def _updateUponMaterialMetadataChange(self) -> None:
         if self._global_container_stack is None:
             return
         with postponeSignals(*self._getContainerChangedSignals(), compress = CompressTechnique.CompressPerParameterValue):
             self.updateMaterialWithVariant(None)
             self._updateQualityWithMaterial()
+
+    ##  This function will translate any printer type name to an abbreviated printer type name
+    @pyqtSlot(str, result = str)
+    def getAbbreviatedMachineName(self, machine_type_name: str) -> str:
+        abbr_machine = ""
+        for word in re.findall(r"[\w']+", machine_type_name):
+            if word.lower() == "ultimaker":
+                abbr_machine += "UM"
+            elif word.isdigit():
+                abbr_machine += word
+            else:
+                stripped_word = "".join(char for char in unicodedata.normalize("NFD", word.upper()) if unicodedata.category(char) != "Mn")
+                # - use only the first character if the word is too long (> 3 characters)
+                # - use the whole word if it's not too long (<= 3 characters)
+                if len(stripped_word) > 3:
+                    stripped_word = stripped_word[0]
+                abbr_machine += stripped_word
+
+        return abbr_machine

cura/Settings/MachineNameValidator.py

@@ -35,10 +35,9 @@ class MachineNameValidator(QObject):
     ##  Check if a specified machine name is allowed.
     #
     #   \param name The machine name to check.
-    #   \param position The current position of the cursor in the text box.
     #   \return ``QValidator.Invalid`` if it's disallowed, or
     #   ``QValidator.Acceptable`` if it's allowed.
-    def validate(self, name, position):
+    def validate(self, name):
         #Check for file name length of the current settings container (which is the longest file we're saving with the name).
         try:
             filename_max_length = os.statvfs(Resources.getDataStoragePath()).f_namemax
@@ -54,7 +53,7 @@ class MachineNameValidator(QObject):
     ##  Updates the validation state of a machine name text field.
     @pyqtSlot(str)
     def updateValidation(self, new_name):
-        is_valid = self.validate(new_name, 0)
+        is_valid = self.validate(new_name)
         if is_valid == QValidator.Acceptable:
             self.validation_regex = "^.*$" #Matches anything.
         else:

cura/Settings/SettingInheritanceManager.py

@@ -1,6 +1,6 @@
 # Copyright (c) 2017 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
-from typing import List
+from typing import List, Optional, TYPE_CHECKING
 
 from PyQt5.QtCore import QObject, QTimer, pyqtProperty, pyqtSignal
 from UM.FlameProfiler import pyqtSlot
@@ -20,13 +20,18 @@ from UM.Settings.SettingInstance import InstanceState
 
 from cura.Settings.ExtruderManager import ExtruderManager
 
+if TYPE_CHECKING:
+    from cura.Settings.ExtruderStack import ExtruderStack
+    from UM.Settings.SettingDefinition import SettingDefinition
+
+
 class SettingInheritanceManager(QObject):
-    def __init__(self, parent = None):
+    def __init__(self, parent = None) -> None:
         super().__init__(parent)
         Application.getInstance().globalContainerStackChanged.connect(self._onGlobalContainerChanged)
-        self._global_container_stack = None
-        self._settings_with_inheritance_warning = []
-        self._active_container_stack = None
+        self._global_container_stack = None  # type: Optional[ContainerStack]
+        self._settings_with_inheritance_warning = []  # type: List[str]
+        self._active_container_stack = None  # type: Optional[ExtruderStack]
         self._onGlobalContainerChanged()
 
         ExtruderManager.getInstance().activeExtruderChanged.connect(self._onActiveExtruderChanged)
@@ -41,7 +46,9 @@ class SettingInheritanceManager(QObject):
 
     ##  Get the keys of all children settings with an override.
     @pyqtSlot(str, result = "QStringList")
-    def getChildrenKeysWithOverride(self, key):
+    def getChildrenKeysWithOverride(self, key: str) -> List[str]:
+        if self._global_container_stack is None:
+            return []
         definitions = self._global_container_stack.definition.findDefinitions(key=key)
         if not definitions:
             Logger.log("w", "Could not find definition for key [%s]", key)
@@ -53,9 +60,11 @@ class SettingInheritanceManager(QObject):
         return result
 
     @pyqtSlot(str, str, result = "QStringList")
-    def getOverridesForExtruder(self, key, extruder_index):
-        result = []
+    def getOverridesForExtruder(self, key: str, extruder_index: str) -> List[str]:
+        if self._global_container_stack is None:
+            return []
 
+        result = []  # type: List[str]
         extruder_stack = ExtruderManager.getInstance().getExtruderStack(extruder_index)
         if not extruder_stack:
             Logger.log("w", "Unable to find extruder for current machine with index %s", extruder_index)
@@ -73,16 +82,16 @@ class SettingInheritanceManager(QObject):
         return result
 
     @pyqtSlot(str)
-    def manualRemoveOverride(self, key):
+    def manualRemoveOverride(self, key: str) -> None:
         if key in self._settings_with_inheritance_warning:
             self._settings_with_inheritance_warning.remove(key)
             self.settingsWithIntheritanceChanged.emit()
 
     @pyqtSlot()
-    def forceUpdate(self):
+    def forceUpdate(self) -> None:
         self._update()
 
-    def _onActiveExtruderChanged(self):
+    def _onActiveExtruderChanged(self) -> None:
         new_active_stack = ExtruderManager.getInstance().getActiveExtruderStack()
         if not new_active_stack:
             self._active_container_stack = None
@@ -94,13 +103,14 @@ class SettingInheritanceManager(QObject):
                 self._active_container_stack.containersChanged.disconnect(self._onContainersChanged)
 
             self._active_container_stack = new_active_stack
-            self._active_container_stack.propertyChanged.connect(self._onPropertyChanged)
-            self._active_container_stack.containersChanged.connect(self._onContainersChanged)
+            if self._active_container_stack is not None:
+                self._active_container_stack.propertyChanged.connect(self._onPropertyChanged)
+                self._active_container_stack.containersChanged.connect(self._onContainersChanged)
             self._update()  # Ensure that the settings_with_inheritance_warning list is populated.
 
-    def _onPropertyChanged(self, key, property_name):
+    def _onPropertyChanged(self, key: str, property_name: str) -> None:
         if (property_name == "value" or property_name == "enabled") and self._global_container_stack:
-            definitions = self._global_container_stack.definition.findDefinitions(key = key)
+            definitions = self._global_container_stack.definition.findDefinitions(key = key)  # type: List["SettingDefinition"]
             if not definitions:
                 return
 
@@ -139,7 +149,7 @@ class SettingInheritanceManager(QObject):
             if settings_with_inheritance_warning_changed:
                 self.settingsWithIntheritanceChanged.emit()
 
-    def _recursiveCheck(self, definition):
+    def _recursiveCheck(self, definition: "SettingDefinition") -> bool:
         for child in definition.children:
             if child.key in self._settings_with_inheritance_warning:
                 return True
@@ -149,7 +159,7 @@ class SettingInheritanceManager(QObject):
         return False
 
     @pyqtProperty("QVariantList", notify = settingsWithIntheritanceChanged)
-    def settingsWithInheritanceWarning(self):
+    def settingsWithInheritanceWarning(self) -> List[str]:
         return self._settings_with_inheritance_warning
 
     ##  Check if a setting has an inheritance function that is overwritten
@@ -157,9 +167,14 @@ class SettingInheritanceManager(QObject):
         has_setting_function = False
         if not stack:
             stack = self._active_container_stack
-        if not stack: #No active container stack yet!
+        if not stack:  # No active container stack yet!
             return False
-        containers = [] # type: List[ContainerInterface]
+
+        if self._active_container_stack is None:
+            return False
+        all_keys = self._active_container_stack.getAllKeys()
+
+        containers = []  # type: List[ContainerInterface]
 
         ## Check if the setting has a user state. If not, it is never overwritten.
         has_user_state = stack.getProperty(key, "state") == InstanceState.User
@@ -190,8 +205,8 @@ class SettingInheritanceManager(QObject):
                 has_setting_function = isinstance(value, SettingFunction)
                 if has_setting_function:
                     for setting_key in value.getUsedSettingKeys():
-                        if setting_key in self._active_container_stack.getAllKeys():
-                            break # We found an actual setting. So has_setting_function can remain true
+                        if setting_key in all_keys:
+                            break  # We found an actual setting. So has_setting_function can remain true
                     else:
                         # All of the setting_keys turned out to not be setting keys at all!
                         # This can happen due enum keys also being marked as settings.
@@ -205,7 +220,7 @@ class SettingInheritanceManager(QObject):
                 break  # There is a setting function somewhere, stop looking deeper.
         return has_setting_function and has_non_function_value
 
-    def _update(self):
+    def _update(self) -> None:
         self._settings_with_inheritance_warning = []  # Reset previous data.
 
         # Make sure that the GlobalStack is not None. sometimes the globalContainerChanged signal gets here late.
@@ -226,7 +241,7 @@ class SettingInheritanceManager(QObject):
         # Notify others that things have changed.
         self.settingsWithIntheritanceChanged.emit()
 
-    def _onGlobalContainerChanged(self):
+    def _onGlobalContainerChanged(self) -> None:
         if self._global_container_stack:
             self._global_container_stack.propertyChanged.disconnect(self._onPropertyChanged)
             self._global_container_stack.containersChanged.disconnect(self._onContainersChanged)

cura/Settings/SettingVisibilityPreset.py

@@ -0,0 +1,90 @@
+import os
+import urllib.parse
+from configparser import ConfigParser
+from typing import List
+
+from PyQt5.QtCore import pyqtProperty, QObject, pyqtSignal
+
+from UM.Logger import Logger
+from UM.MimeTypeDatabase import MimeTypeDatabase
+
+
+class SettingVisibilityPreset(QObject):
+    onSettingsChanged = pyqtSignal()
+    onNameChanged = pyqtSignal()
+    onWeightChanged = pyqtSignal()
+    onIdChanged = pyqtSignal()
+
+    def __init__(self, preset_id: str = "", name: str = "", weight: int = 0, parent = None) -> None:
+        super().__init__(parent)
+        self._settings = []  # type: List[str]
+        self._id = preset_id
+        self._weight = weight
+        self._name = name
+
+    @pyqtProperty("QStringList", notify = onSettingsChanged)
+    def settings(self) -> List[str]:
+        return self._settings
+
+    @pyqtProperty(str, notify = onIdChanged)
+    def presetId(self) -> str:
+        return self._id
+
+    @pyqtProperty(int, notify = onWeightChanged)
+    def weight(self) -> int:
+        return self._weight
+
+    @pyqtProperty(str, notify = onNameChanged)
+    def name(self) -> str:
+        return self._name
+
+    def setName(self, name: str) -> None:
+        if name != self._name:
+            self._name = name
+            self.onNameChanged.emit()
+
+    def setId(self, id: str) -> None:
+        if id != self._id:
+            self._id = id
+            self.onIdChanged.emit()
+
+    def setWeight(self, weight: int) -> None:
+        if weight != self._weight:
+            self._weight = weight
+            self.onWeightChanged.emit()
+
+    def setSettings(self, settings: List[str]) -> None:
+        if set(settings) != set(self._settings):
+            self._settings = list(set(settings))  # filter out non unique
+            self.onSettingsChanged.emit()
+
+    #   Load a preset from file. We expect a file that can be parsed by means of the config parser.
+    #   The sections indicate the categories and the parameters placed in it (which don't need values) are the settings
+    #   that should be considered visible.
+    def loadFromFile(self, file_path: str) -> None:
+        mime_type = MimeTypeDatabase.getMimeTypeForFile(file_path)
+
+        item_id = urllib.parse.unquote_plus(mime_type.stripExtension(os.path.basename(file_path)))
+        if not os.path.isfile(file_path):
+            Logger.log("e", "[%s] is not a file", file_path)
+            return None
+
+        parser = ConfigParser(interpolation = None, allow_no_value = True)  # Accept options without any value,
+
+        parser.read([file_path])
+        if not parser.has_option("general", "name") or not parser.has_option("general", "weight"):
+            return None
+
+        settings = []  # type: List[str]
+        for section in parser.sections():
+            if section == "general":
+                continue
+
+            settings.append(section)
+            for option in parser[section].keys():
+                settings.append(option)
+        self.setSettings(settings)
+        self.setId(item_id)
+        self.setName(parser["general"]["name"])
+        self.setWeight(int(parser["general"]["weight"]))
+

cura/Settings/SidebarCustomMenuItemsModel.py

@@ -18,7 +18,7 @@ class SidebarCustomMenuItemsModel(ListModel):
         self.addRoleName(self.name_role, "name")
         self.addRoleName(self.actions_role, "actions")
         self.addRoleName(self.menu_item_role, "menu_item")
-        self.addRoleName(self.menu_item_icon_name_role, "iconName")
+        self.addRoleName(self.menu_item_icon_name_role, "icon_name")
         self._updateExtensionList()
 
     def _updateExtensionList(self)-> None:

cura/Settings/SimpleModeSettingsManager.py

@@ -1,7 +1,8 @@
 # Copyright (c) 2017 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
+from typing import Set
 
-from PyQt5.QtCore import QObject, pyqtSignal, pyqtProperty
+from PyQt5.QtCore import QObject, pyqtSignal, pyqtProperty, pyqtSlot
 
 from UM.Application import Application
 
@@ -16,15 +17,11 @@ class SimpleModeSettingsManager(QObject):
         self._is_profile_user_created = False  # True when profile was custom created by user
 
         self._machine_manager.activeStackValueChanged.connect(self._updateIsProfileCustomized)
-        self._machine_manager.activeQualityGroupChanged.connect(self._updateIsProfileUserCreated)
-        self._machine_manager.activeQualityChangesGroupChanged.connect(self._updateIsProfileUserCreated)
 
         # update on create as the activeQualityChanged signal is emitted before this manager is created when Cura starts
         self._updateIsProfileCustomized()
-        self._updateIsProfileUserCreated()
 
     isProfileCustomizedChanged = pyqtSignal()
-    isProfileUserCreatedChanged = pyqtSignal()
 
     @pyqtProperty(bool, notify = isProfileCustomizedChanged)
     def isProfileCustomized(self):
@@ -57,33 +54,6 @@ class SimpleModeSettingsManager(QObject):
             self._is_profile_customized = has_customized_user_settings
             self.isProfileCustomizedChanged.emit()
 
-    @pyqtProperty(bool, notify = isProfileUserCreatedChanged)
-    def isProfileUserCreated(self):
-        return self._is_profile_user_created
-
-    def _updateIsProfileUserCreated(self):
-        quality_changes_keys = set()
-
-        if not self._machine_manager.activeMachine:
-            return False
-
-        global_stack = self._machine_manager.activeMachine
-
-        # check quality changes settings in the global stack
-        quality_changes_keys.update(global_stack.qualityChanges.getAllKeys())
-
-        # check quality changes settings in the extruder stacks
-        if global_stack.extruders:
-            for extruder_stack in global_stack.extruders.values():
-                quality_changes_keys.update(extruder_stack.qualityChanges.getAllKeys())
-
-        # check if the qualityChanges container is not empty (meaning it is a user created profile)
-        has_quality_changes = len(quality_changes_keys) > 0
-
-        if has_quality_changes != self._is_profile_user_created:
-            self._is_profile_user_created = has_quality_changes
-            self.isProfileUserCreatedChanged.emit()
-
     # These are the settings included in the Simple ("Recommended") Mode, so only when the other settings have been
     # changed, we consider it as a user customized profile in the Simple ("Recommended") Mode.
     __ignored_custom_setting_keys = ["support_enable",

cura/Settings/UserChangesModel.py

@@ -1,15 +1,17 @@
-from UM.Qt.ListModel import ListModel
+# Copyright (c) 2018 Ultimaker B.V.
+# Cura is released under the terms of the LGPLv3 or higher.
+
+import os
+from collections import OrderedDict
 
 from PyQt5.QtCore import pyqtSlot, Qt
+
 from UM.Application import Application
-from cura.Settings.ExtruderManager import ExtruderManager
 from UM.Settings.ContainerRegistry import ContainerRegistry
 from UM.i18n import i18nCatalog
 from UM.Settings.SettingFunction import SettingFunction
-from UM.Settings.PropertyEvaluationContext import PropertyEvaluationContext
 
-from collections import OrderedDict
-import os
+from UM.Qt.ListModel import ListModel
 
 
 class UserChangesModel(ListModel):
@@ -38,12 +40,18 @@ class UserChangesModel(ListModel):
         self._update()
 
     def _update(self):
+        application = Application.getInstance()
+        machine_manager = application.getMachineManager()
+        cura_formula_functions = application.getCuraFormulaFunctions()
+
         item_dict = OrderedDict()
         item_list = []
-        global_stack = Application.getInstance().getGlobalContainerStack()
+        global_stack = machine_manager.activeMachine
         if not global_stack:
             return
-        stacks = ExtruderManager.getInstance().getActiveGlobalAndExtruderStacks()
+
+        stacks = [global_stack]
+        stacks.extend(global_stack.extruders.values())
 
         # Check if the definition container has a translation file and ensure it's loaded.
         definition = global_stack.getBottom()
@@ -69,13 +77,7 @@ class UserChangesModel(ListModel):
 
             # Override "getExtruderValue" with "getDefaultExtruderValue" so we can get the default values
             user_changes = containers.pop(0)
-            default_value_resolve_context = PropertyEvaluationContext(stack)
-            default_value_resolve_context.context["evaluate_from_container_index"] = 1  # skip the user settings container
-            default_value_resolve_context.context["override_operators"] = {
-                "extruderValue": ExtruderManager.getDefaultExtruderValue,
-                "extruderValues": ExtruderManager.getDefaultExtruderValues,
-                "resolveOrValue": ExtruderManager.getDefaultResolveOrValue
-            }
+            default_value_resolve_context = cura_formula_functions.createContextForDefaultValueEvaluation(stack)
 
             for setting_key in user_changes.getAllKeys():
                 original_value = None

cura/Stages/CuraStage.py

@@ -1,23 +1,29 @@
-# Copyright (c) 2017 Ultimaker B.V.
+# Copyright (c) 2018 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
+
 from PyQt5.QtCore import pyqtProperty, QUrl
 
 from UM.Stage import Stage
 
 
+# Since Cura has a few pre-defined "space claims" for the locations of certain components, we've provided some structure
+# to indicate this.
+# * The StageMenuComponent is the horizontal area below the stage bar. This should be used to show stage specific
+#   buttons and elements. This component will be drawn over the bar & main component.
+# * The MainComponent is the component that will be drawn starting from the bottom of the stageBar and fills the rest
+#   of the screen.
 class CuraStage(Stage):
-
-    def __init__(self, parent = None):
+    def __init__(self, parent = None) -> None:
         super().__init__(parent)
 
     @pyqtProperty(str, constant = True)
-    def stageId(self):
+    def stageId(self) -> str:
         return self.getPluginId()
 
     @pyqtProperty(QUrl, constant = True)
-    def mainComponent(self):
+    def mainComponent(self) -> QUrl:
         return self.getDisplayComponent("main")
 
     @pyqtProperty(QUrl, constant = True)
-    def sidebarComponent(self):
-        return self.getDisplayComponent("sidebar")
+    def stageMenuComponent(self) -> QUrl:
+        return self.getDisplayComponent("menu")