diff --git a/cura/QualityManager.py b/cura/QualityManager.py new file mode 100644 index 0000000000..9d7eac8a05 --- /dev/null +++ b/cura/QualityManager.py @@ -0,0 +1,132 @@ +# Copyright (c) 2016 Ultimaker B.V. +# Cura is released under the terms of the AGPLv3 or higher. + +import UM.Application +import cura.Settings.ExtruderManager +import UM.Settings.ContainerRegistry + +# This collects a lot of quality and quality changes related code which was split between ContainerManager +# and the MachineManager and really needs to usable from both. + +class QualityManager: + + ## Get the singleton instance for this class. + @classmethod + def getInstance(cls): + # Note: Explicit use of class name to prevent issues with inheritance. + if QualityManager.__instance is None: + QualityManager.__instance = cls() + return QualityManager.__instance + + __instance = None + + ## Find a quality by name for a specific machine definition and materials. + # + # \param quality_name + # \param machine_definition (Optional) \type{ContainerInstance} If nothing is + # specified then the currently selected machine definition is used. + # \param material_containers (Optional) \type{List[ContainerInstance]} If nothing is specified then + # the current set of selected materials is used. + # \return the matching quality containers \type{List[ContainerInstance]} + def findQualityByName(self, quality_name, machine_definition=None, material_containers=None): + criteria = {"type": "quality", "name": quality_name} + return self._getFilteredContainersForStack(machine_definition, material_containers, **criteria) + + ## Find a quality changes container by name. + # + # \param quality_changes_name \type{str} the name of the quality changes container. + # \param machine_definition (Optional) \type{ContainerInstance} If nothing is + # specified then the currently selected machine definition is used. + # \param material_containers (Optional) \type{List[ContainerInstance]} If nothing is specified then + # the current set of selected materials is used. + # \return the matching quality changes containers \type{List[ContainerInstance]} + def findQualityChangesByName(self, quality_changes_name, machine_definition=None, material_containers=None): + criteria = {"type": "quality_changes", "name": quality_changes_name} + return self._getFilteredContainersForStack(machine_definition, material_containers, **criteria) + + ## Find a quality container by quality type. + # + # \param quality_type \type{str} the name of the quality type to search for. + # \param machine_definition (Optional) \type{ContainerInstance} If nothing is + # specified then the currently selected machine definition is used. + # \param material_containers (Optional) \type{List[ContainerInstance]} If nothing is specified then + # the current set of selected materials is used. + # \return the matching quality containers \type{List[ContainerInstance]} + def findQualityByQualityType(self, quality_type, machine_definition=None, material_containers=None): + criteria = {"type": "quality", "quality_type": quality_type} + return self._getFilteredContainersForStack(machine_definition, material_containers, **criteria) + + def _getFilteredContainers(self, **kwargs): + return self._getFilteredContainersForStack(None, None **kwargs) + + def _getFilteredContainersForStack(self, machine_definition=None, material_containers=None, **kwargs): + # Fill in any default values. + if machine_definition is None: + machine_definition = UM.Application.getInstance().getGlobalContainerStack().getBottom() + quality_definition = machine_definition.getMetaDataEntry("quality_definition") + if quality_definition is not None: + machine_definition = UM.Settings.ContainerRegistry.getInstance().findDefinitionContainers(id=quality_definition)[0] + + machine_definition = self.getParentMachineDefinition(machine_definition) + + if material_containers is None: + active_stacks = cura.Settings.ExtruderManager.getInstance().getActiveGlobalAndExtruderStacks() + material_containers = [stack.findContainer(type="material") for stack in active_stacks] + + criteria = kwargs + filter_by_material = False + + if machine_definition.getMetaDataEntry("has_machine_quality"): + definition_id = machine_definition.getMetaDataEntry("quality_definition", machine_definition.getId()) + criteria["definition"] = definition_id + + filter_by_material = machine_definition.getMetaDataEntry("has_materials") + + # Stick the material IDs in a set + if material_containers is None: + filter_by_material = False + else: + material_ids = set() + for material_instance in material_containers: + material_ids.add(material_instance.getId()) + + containers = UM.Settings.ContainerRegistry.getInstance().findInstanceContainers(**criteria) + + result = [] + for container in containers: + # If the machine specifies we should filter by material, exclude containers that do not match any active material. + if filter_by_material and container.getMetaDataEntry("material") not in material_ids: + continue + result.append(container) + return result + + ## Get the parent machine definition of a machine definition. + # + # \param machine_definition \type{DefinitionContainer} This may be a normal machine definition or + # an extruder definition. + # \return \type{DefinitionContainer} the parent machine definition. If the given machine + # definition doesn't have a parent then it is simply returned. + def getParentMachineDefinition(self, machine_definition): + container_registry = UM.Settings.ContainerRegistry.getInstance() + + machine_entry = machine_definition.getMetaDataEntry("machine") + if machine_entry is None: + # We have a normal (whole) machine defintion + quality_definition = machine_definition.getMetaDataEntry("quality_definition") + if quality_definition is not None: + parent_machine_definition = container_registry.findDefinitionContainers(id=quality_definition)[0] + return self.getParentMachineDefinition(parent_machine_definition) + else: + return machine_definition + else: + # This looks like an extruder. Find the rest of the machine. + whole_machine = container_registry.findDefinitionContainers(id=machine_entry)[0] + parent_machine = self.getParentMachineDefinition(whole_machine) + if whole_machine is parent_machine: + # This extruder already belongs to a 'parent' machine def. + return machine_definition + else: + # Look up the corresponding extruder definition in the parent machine definition. + extruder_position = machine_definition.getMetaDataEntry("position") + parent_extruder_id = parent_machine.getMetaDataEntry("machine_extruder_trains")[extruder_position] + return container_registry.findDefinitionContainers(id=parent_extruder_id)[0] diff --git a/cura/Settings/ContainerManager.py b/cura/Settings/ContainerManager.py index e3a0d22299..a0648587c2 100644 --- a/cura/Settings/ContainerManager.py +++ b/cura/Settings/ContainerManager.py @@ -15,6 +15,7 @@ import UM.MimeTypeDatabase import UM.Logger import cura.Settings +from cura.QualityManager import QualityManager from UM.MimeTypeDatabase import MimeTypeNotFoundError @@ -468,7 +469,7 @@ class ContainerManager(QObject): UM.Logger.log("w", "No quality or quality changes container found in stack %s, ignoring it", stack.getId()) continue - new_changes = self._createQualityChanges(quality_container, unique_name, stack.getId()) + new_changes = self._createQualityChanges(quality_container, unique_name, stack.getId(), UM.Application.getInstance().getGlobalContainerStack()) self._performMerge(new_changes, user_container) self._container_registry.addContainer(new_changes) @@ -566,33 +567,80 @@ class ContainerManager(QObject): global_stack = UM.Application.getInstance().getGlobalContainerStack() if not global_stack or not quality_name: return "" + machine_definition = global_stack.getBottom() + + active_stacks = cura.Settings.ExtruderManager.getInstance().getActiveGlobalAndExtruderStacks() + material_containers = [stack.findContainer(type="material") for stack in active_stacks] + + result = self._duplicateQualityOrQualityChangesForMachineType(quality_name, base_name, + QualityManager.getInstance().getParentMachineDefinition(machine_definition), + material_containers) + return result[0].getName() if result else "" + + ## Duplicate a quality or quality changes profile specific to a machine type + # + # \param quality_name \type{str} the name of the quality or quality changes container to duplicate. + # \param base_name \type{str} the desired name for the new container. + # \param machine_definition \type{DefinitionContainer} + # \param material_instances \type{List[InstanceContainer]} + # \return \type{str} the name of the newly created container. + def _duplicateQualityOrQualityChangesForMachineType(self, quality_name, base_name, machine_definition, material_instances): UM.Logger.log("d", "Attempting to duplicate the quality %s", quality_name) - containers = self._container_registry.findInstanceContainers(name = quality_name) - if not containers: + + # Try Quality + containers = QualityManager.getInstance().findQualityByName(quality_name, machine_definition, material_instances) + if containers: + container = containers[0] + if base_name is None: + base_name = quality_name + return self._duplicateQualityForMachineType(container, base_name, machine_definition) + + # Try quality changes. + containers = QualityManager.getInstance().findQualityChangesByName(quality_name, machine_definition, material_instances) + if containers: + container = containers[0] + if base_name is None: + base_name = quality_name + return self._duplicateQualityChangesForMachineType(container, base_name, machine_definition) + else: UM.Logger.log("d", "Unable to duplicate the quality %s, because it doesn't exist.", quality_name) return "" + # Duplicate a quality profile + def _duplicateQualityForMachineType(self, quality_container, base_name, machine_definition): if base_name is None: - base_name = quality_name - + base_name = quality_container.getName() new_name = self._container_registry.uniqueName(base_name) - container_type = containers[0].getMetaDataEntry("type") - if container_type == "quality": - for container in self._getFilteredContainers(name = quality_name, type = "quality"): - for stack in cura.Settings.ExtruderManager.getInstance().getActiveGlobalAndExtruderStacks(): - new_changes = self._createQualityChanges(container, new_name, stack.getId()) - self._container_registry.addContainer(new_changes) - elif container_type == "quality_changes": - for container in self._getFilteredContainers(name = quality_name, type = "quality_changes"): - stack_id = container.getMetaDataEntry("extruder", global_stack.getId()) - new_container = container.duplicate(self._createUniqueId(stack_id, new_name), new_name) - self._container_registry.addContainer(new_container) - else: - UM.Logger.log("w", "Unable to duplicate profile. It has the wrong type.") - return "" + new_change_instances = [] - return new_name + # Handle the global stack first. + new_changes = self._createQualityChanges(quality_container, new_name, machine_definition, None) + new_change_instances.append(new_changes) + self._container_registry.addContainer(new_changes) + + # Handle the extruders if present. + extruders = machine_definition.getMetaDataEntry("machine_extruder_trains") + if extruders: + for key in extruders: + value = extruders[key] + new_changes = self._createQualityChanges(quality_container, new_name, machine_definition, value) + new_change_instances.append(new_changes) + self._container_registry.addContainer(new_changes) + + return new_change_instances + + # Duplicate a quality changes container + def _duplicateQualityChangesForMachineType(self, quality_changes_container, base_name, machine_definition): + new_change_instances = [] + for container in QualityManager.getInstance().findQualityChangesByName(quality_changes_container.getName(), + machine_definition, None): + new_unique_id = self._createUniqueId(container.getId(), base_name) + new_container = container.duplicate(new_unique_id, base_name) + new_change_instances.append(new_container) + self._container_registry.addContainer(new_container) + + return new_change_instances @pyqtSlot(str, result = str) def duplicateMaterial(self, material_id): @@ -677,39 +725,13 @@ class ContainerManager(QObject): name_filter = "{0} ({1})".format(mime_type.comment, suffix_list) self._container_name_filters[name_filter] = entry - ## Return a generator that iterates over a set of containers that are filtered by machine and material when needed. + ## Get containers filtered by machine type and material if required. # # \param kwargs Initial search criteria that the containers need to match. # - # \return A generator that iterates over the list of containers matching the search criteria. + # \return A list of containers matching the search criteria. def _getFilteredContainers(self, **kwargs): - global_stack = UM.Application.getInstance().getGlobalContainerStack() - if not global_stack: - return False - - criteria = kwargs - - filter_by_material = False - - if global_stack.getMetaDataEntry("has_machine_quality"): - definition = global_stack.getBottom() - definition_id = definition.getMetaDataEntry("quality_definition", definition.getId()) - criteria["definition"] = definition_id - - filter_by_material = global_stack.getMetaDataEntry("has_materials") - - material_ids = [] - if filter_by_material: - for stack in cura.Settings.ExtruderManager.getInstance().getActiveGlobalAndExtruderStacks(): - material_ids.append(stack.findContainer(type = "material").getId()) - - containers = self._container_registry.findInstanceContainers(**criteria) - for container in containers: - # If the machine specifies we should filter by material, exclude containers that do not match any active material. - if filter_by_material and container.getMetaDataEntry("material") not in material_ids: - continue - - yield container + return QualityManager.getInstance()._getFilteredContainers(**kwargs) ## Creates a unique ID for a container by prefixing the name with the stack ID. # @@ -731,34 +753,26 @@ class ContainerManager(QObject): # # \param quality_container The quality container to create a changes container for. # \param new_name The name of the new quality_changes container. - # \param stack_id The ID of the container stack the new container "belongs to". It is used primarily to ensure a unique ID. + # \param machine_definition The machine definition this quality changes container is specific to. + # \param extruder_id # # \return A new quality_changes container with the specified container as base. - def _createQualityChanges(self, quality_container, new_name, stack_id): - global_stack = UM.Application.getInstance().getGlobalContainerStack() - assert global_stack is not None + def _createQualityChanges(self, quality_container, new_name, machine_definition, extruder_id): + base_id = machine_definition.getId() if extruder_id is None else extruder_id # Create a new quality_changes container for the quality. - quality_changes = UM.Settings.InstanceContainer(self._createUniqueId(stack_id, new_name)) + quality_changes = UM.Settings.InstanceContainer(self._createUniqueId(base_id, new_name)) quality_changes.setName(new_name) quality_changes.addMetaDataEntry("type", "quality_changes") - quality_changes.addMetaDataEntry("quality", quality_container.getMetaDataEntry("quality_type")) + quality_changes.addMetaDataEntry("quality_type", quality_container.getMetaDataEntry("quality_type")) # If we are creating a container for an extruder, ensure we add that to the container - if stack_id != global_stack.getId(): - quality_changes.addMetaDataEntry("extruder", stack_id) + if extruder_id is not None: + quality_changes.addMetaDataEntry("extruder", extruder_id) # If the machine specifies qualities should be filtered, ensure we match the current criteria. - if not global_stack.getMetaDataEntry("has_machine_quality"): + if not machine_definition.getMetaDataEntry("has_machine_quality"): quality_changes.setDefinition(self._container_registry.findContainers(id = "fdmprinter")[0]) else: - definition = global_stack.getBottom() - definition_id = definition.getMetaDataEntry("quality_definition", definition.getId()) - definition = self._container_registry.findContainers(id=definition_id)[0] - quality_changes.setDefinition(definition) - - if global_stack.getMetaDataEntry("has_materials"): - material = quality_container.getMetaDataEntry("material") - quality_changes.addMetaDataEntry("material", material) - + quality_changes.setDefinition(QualityManager.getInstance().getParentMachineDefinition(machine_definition)) return quality_changes diff --git a/cura/Settings/MachineManager.py b/cura/Settings/MachineManager.py index 450e7606b9..451be66862 100644 --- a/cura/Settings/MachineManager.py +++ b/cura/Settings/MachineManager.py @@ -12,6 +12,7 @@ from UM.Settings.SettingRelation import RelationType import UM.Settings +from cura.QualityManager import QualityManager from cura.PrinterOutputDevice import PrinterOutputDevice from . import ExtruderManager @@ -535,10 +536,10 @@ class MachineManager(QObject): if not old_material: Logger.log("w", "While trying to set the active material, no material was found to replace it.") return - if (old_quality_changes.getId() == "empty_quality_changes" or #Don't want the empty one. - old_quality_changes.getMetaDataEntry("material") != material_id): # The quality change is based off a different material; the quality change is probably a custom quality. + if old_quality_changes.getId() == "empty_quality_changes": old_quality_changes = None + self.blurSettings.emit() old_material.nameChanged.disconnect(self._onMaterialNameChanged) @@ -596,22 +597,26 @@ class MachineManager(QObject): Logger.log("d", "Attempting to change the active quality to %s", quality_id) self.blurSettings.emit() - quality_container = None + quality_changes_container = self._empty_quality_changes_container + # Quality profile come in two flavours: type=quality and type=quality_changes + # If we found a quality_changes profile then look up its parent quality profile. container_type = containers[0].getMetaDataEntry("type") # Get quality container and optionally the quality_changes container. if container_type == "quality": quality_container = containers[0] + elif container_type == "quality_changes": quality_changes_container = containers[0] - containers = UM.Settings.ContainerRegistry.getInstance().findInstanceContainers( - quality_type = quality_changes_container.getMetaDataEntry("quality")) + # Find a suitable quality container to match this quality changes container. + containers = QualityManager.getInstance().findQualityByQualityType(quality_changes_container.getMetaDataEntry("quality_type")) if not containers: Logger.log("e", "Could not find quality %s for changes %s, not changing quality", quality_changes_container.getMetaDataEntry("quality"), quality_changes_container.getId()) return quality_container = containers[0] + else: Logger.log("e", "Tried to set quality to a container that is not of the right type") return @@ -620,25 +625,33 @@ class MachineManager(QObject): if not quality_type: quality_type = quality_changes_container.getName() - # Find suitable quality containers (by quality_type) for each stack and swap out the container. + # Find and swap in the quality changes containers for the global stack and each extruder stack. stacks = list(ExtruderManager.getInstance().getActiveGlobalAndExtruderStacks()) name_changed_connect_stacks = [] # Connect these stacks to the name changed callback - for stack in stacks: - extruder_id = stack.getId() if stack != self._global_container_stack else None - - criteria = { "quality_type": quality_type, "extruder": extruder_id } + for stack in ExtruderManager.getInstance().getActiveGlobalAndExtruderStacks(): + if stack != self._global_container_stack: + # Must be an extruder stack. Use the ID of the extruders as specified by the machine definition. + extruder_id = QualityManager.getInstance().getParentMachineDefinition(stack.getBottom()).getId() + else: + extruder_id = None + criteria = { "quality_type": quality_type, "type": "quality", "extruder": extruder_id } + # Filter candidate quality containers by the current material in the stack. material = stack.findContainer(type = "material") if material and material is not self._empty_material_container: criteria["material"] = material.getId() + # Apply a filter when machines have their own specific quality profiles. if self._global_container_stack.getMetaDataEntry("has_machine_quality"): criteria["definition"] = self.activeQualityDefinitionId else: criteria["definition"] = "fdmprinter" + # Find the new quality container. stack_quality = UM.Settings.ContainerRegistry.getInstance().findInstanceContainers(**criteria) if not stack_quality: + # Search again, except this time drop any extruder requirement. We should now get + # the same quality container as the one needed for the global stack. criteria.pop("extruder") stack_quality = UM.Settings.ContainerRegistry.getInstance().findInstanceContainers(**criteria) if not stack_quality: @@ -648,28 +661,21 @@ class MachineManager(QObject): else: stack_quality = stack_quality[0] + # Find the new quality changes if one has been specified. if quality_changes_container != self._empty_quality_changes_container: - stack_quality_changes = UM.Settings.ContainerRegistry.getInstance().findInstanceContainers(name = quality_changes_container.getName(), extruder = extruder_id)[0] + changes = UM.Settings.ContainerRegistry.getInstance().findInstanceContainers( + type="quality_changes", + quality_type=stack_quality.getMetaDataEntry("quality_type"), + name = quality_changes_container.getName(), extruder = extruder_id) + stack_quality_changes = changes[0] else: + # This is case of quality container and the no-op quality changes container. stack_quality_changes = self._empty_quality_changes_container - old_quality = stack.findContainer(type = "quality") - if old_quality: - old_quality.nameChanged.disconnect(self._onQualityNameChanged) - else: - Logger.log("w", "Could not find old quality while changing active quality.") - - old_changes = stack.findContainer(type = "quality_changes") - if old_changes: - old_changes.nameChanged.disconnect(self._onQualityNameChanged) - else: - Logger.log("w", "Could not find old quality_changes while changing active quality.") - - stack.replaceContainer(stack.getContainerIndex(old_quality), stack_quality, postpone_emit = True) - stack.replaceContainer(stack.getContainerIndex(old_changes), stack_quality_changes, postpone_emit = True) - name_changed_connect_stacks.append(stack_quality) name_changed_connect_stacks.append(stack_quality_changes) + self._replaceQualityOrQualityChangesInStack(stack, stack_quality, postpone_emit = True) + self._replaceQualityOrQualityChangesInStack(stack, stack_quality_changes, postpone_emit = True) # Send emits that are postponed in replaceContainer. # Here the stacks are finished replacing and every value can be resolved based on the current state. @@ -680,19 +686,41 @@ class MachineManager(QObject): stack.nameChanged.connect(self._onQualityNameChanged) if self.hasUserSettings and Preferences.getInstance().getValue("cura/active_mode") == 1: - # Ask the user if the user profile should be cleared or not (discarding the current settings) - # In Simple Mode we assume the user always wants to keep the (limited) current settings - details = catalog.i18nc("@label", "You made changes to the following setting(s):") - user_settings = self._active_container_stack.getTop().findInstances(**{}) - for setting in user_settings: - details = details + "\n " + setting.definition.label - - Application.getInstance().messageBox(catalog.i18nc("@window:title", "Switched profiles"), catalog.i18nc("@label", "Do you want to transfer your changed settings to this profile?"), - catalog.i18nc("@label", "If you transfer your settings they will override settings in the profile."), details, - buttons = QMessageBox.Yes + QMessageBox.No, icon = QMessageBox.Question, callback = self._keepUserSettingsDialogCallback) + self._askUserToKeepOrClearCurrentSettings() self.activeQualityChanged.emit() + def _replaceQualityOrQualityChangesInStack(self, stack, container, postpone_emit = False): + # Disconnect the signal handling from the old container. + old_container = stack.findContainer(type=container.getMetaDataEntry("type")) + if old_container: + old_container.nameChanged.disconnect(self._onQualityNameChanged) + else: + Logger.log("w", "Could not find old "+ container.getMetaDataEntry("type") + " while changing active " + container.getMetaDataEntry("type") + ".") + + # Swap in the new container into the stack. + stack.replaceContainer(stack.getContainerIndex(old_container), container, postpone_emit = postpone_emit) + + # Attach the needed signal handling. + container.nameChanged.connect(self._onQualityNameChanged) + + def _askUserToKeepOrClearCurrentSettings(self): + # Ask the user if the user profile should be cleared or not (discarding the current settings) + # In Simple Mode we assume the user always wants to keep the (limited) current settings + details = catalog.i18nc("@label", "You made changes to the following setting(s):") + user_settings = self._active_container_stack.getTop().findInstances(**{}) + for setting in user_settings: + details = details + "\n " + setting.definition.label + + Application.getInstance().messageBox(catalog.i18nc("@window:title", "Switched profiles"), + catalog.i18nc("@label", + "Do you want to transfer your changed settings to this profile?"), + catalog.i18nc("@label", + "If you transfer your settings they will override settings in the profile."), + details, + buttons=QMessageBox.Yes + QMessageBox.No, icon=QMessageBox.Question, + callback=self._keepUserSettingsDialogCallback) + def _keepUserSettingsDialogCallback(self, button): if button == QMessageBox.Yes: # Yes, keep the settings in the user profile with this profile @@ -746,10 +774,7 @@ class MachineManager(QObject): # \param definition (DefinitionContainer) machine definition # \returns DefinitionID (string) if found, empty string otherwise def getQualityDefinitionId(self, definition): - definition_id = definition.getMetaDataEntry("quality_definition") - if not definition_id: - definition_id = definition.getId() - return definition_id + return QualityManager.getInstance().getParentMachineDefinition(definition).getId() ## Get the Variant ID to use to select quality profiles for the currently active variant # \returns VariantID (string) if found, empty string otherwise diff --git a/resources/qml/Menus/ProfileMenu.qml b/resources/qml/Menus/ProfileMenu.qml index 57d0226a97..1c4137a231 100644 --- a/resources/qml/Menus/ProfileMenu.qml +++ b/resources/qml/Menus/ProfileMenu.qml @@ -38,11 +38,11 @@ Menu id: customProfileInstantiator model: UM.InstanceContainersModel { - filter: menu.getFilter({ + filter: ({ "type": "quality_changes", "extruder": null, "definition": Cura.MachineManager.filterQualityByMachine ? Cura.MachineManager.activeQualityDefinitionId : "fdmprinter" - }); + }) onModelReset: customSeparator.visible = rowCount() > 0 } diff --git a/resources/qml/Preferences/ProfilesPage.qml b/resources/qml/Preferences/ProfilesPage.qml index 94e452444e..051dc1f249 100644 --- a/resources/qml/Preferences/ProfilesPage.qml +++ b/resources/qml/Preferences/ProfilesPage.qml @@ -17,22 +17,33 @@ UM.ManagementPage model: UM.InstanceContainersModel { - filter: + filterList: { - var result = { "type": "quality*", "extruder": null }; + var qualityFilter = { "type": "quality", "extruder": null }; if(Cura.MachineManager.filterQualityByMachine) { - result.definition = Cura.MachineManager.activeQualityDefinitionId; + qualityFilter.definition = Cura.MachineManager.activeQualityDefinitionId; if(Cura.MachineManager.hasMaterials) { - result.material = Cura.MachineManager.allActiveMaterialIds[Cura.MachineManager.activeMachineId]; + qualityFilter.material = Cura.MachineManager.allActiveMaterialIds[Cura.MachineManager.activeMachineId]; } } else { - result.definition = "fdmprinter" + qualityFilter.definition = "fdmprinter"; } - return result + + var qualityChangeFilter = { "type": "quality_changes", "extruder": null }; + if(Cura.MachineManager.filterQualityByMachine) + { + qualityChangeFilter.definition = Cura.MachineManager.activeQualityDefinitionId; + } + else + { + qualityChangeFilter.definition = "fdmprinter"; + } + + return [qualityFilter, qualityChangeFilter]; } }