Merge branch 'master' into feature_multiextruder_machinesettings

cura/BuildVolume.py

@@ -600,20 +600,21 @@ class BuildVolume(SceneNode):
                 result_areas[extruder_id].append(polygon) #Don't perform the offset on these.
 
         # Add prime tower location as disallowed area.
-        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(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
+                            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])
-            else:
-                self._error_areas.extend(prime_tower_areas[extruder_id])
+                if not prime_tower_collision:
+                    result_areas[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
 
@@ -955,4 +956,4 @@ class BuildVolume(SceneNode):
     _tower_settings = ["prime_tower_enable", "prime_tower_size", "prime_tower_position_x", "prime_tower_position_y"]
     _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"]
-    _extruder_settings = ["support_enable", "support_interface_enable", "support_infill_extruder_nr", "support_extruder_nr_layer_0", "support_interface_extruder_nr", "brim_line_count", "adhesion_extruder_nr", "adhesion_type"] #Settings that can affect which extruders are used.
+    _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/CuraActions.py

@@ -1,10 +1,23 @@
+# Copyright (c) 2017 Ultimaker B.V.
+# Cura is released under the terms of the AGPLv3 or higher.
+
 from PyQt5.QtCore import QObject, QUrl
 from PyQt5.QtGui import QDesktopServices
 from UM.FlameProfiler import pyqtSlot
 
 from UM.Event import CallFunctionEvent
 from UM.Application import Application
+from UM.Math.Vector import Vector
+from UM.Scene.Selection import Selection
+from UM.Scene.Iterator.BreadthFirstIterator import BreadthFirstIterator
+from UM.Operations.GroupedOperation import GroupedOperation
+from UM.Operations.RemoveSceneNodeOperation import RemoveSceneNodeOperation
+from UM.Operations.SetTransformOperation import SetTransformOperation
 
+from cura.SetParentOperation import SetParentOperation
+from cura.MultiplyObjectsJob import MultiplyObjectsJob
+from cura.Settings.SetObjectExtruderOperation import SetObjectExtruderOperation
+from cura.Settings.ExtruderManager import ExtruderManager
 
 class CuraActions(QObject):
     def __init__(self, parent = None):
@@ -23,5 +36,84 @@ class CuraActions(QObject):
         event = CallFunctionEvent(self._openUrl, [QUrl("http://github.com/Ultimaker/Cura/issues")], {})
         Application.getInstance().functionEvent(event)
 
+    ##  Center all objects in the selection
+    @pyqtSlot()
+    def centerSelection(self) -> None:
+        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()
+
+            center_operation = SetTransformOperation(current_node, Vector())
+            operation.addOperation(center_operation)
+        operation.push()
+
+    ##  Multiply all objects in the selection
+    #
+    #   \param count The number of times to multiply the selection.
+    @pyqtSlot(int)
+    def multiplySelection(self, count: int) -> None:
+        job = MultiplyObjectsJob(Selection.getAllSelectedObjects(), count, 8)
+        job.start()
+
+    ##  Delete all selected objects.
+    @pyqtSlot()
+    def deleteSelection(self) -> None:
+        if not Application.getInstance().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()
+
+    ##  Set the extruder that should be used to print the selection.
+    #
+    #   \param extruder_id The ID of the extruder stack to use for the selected objects.
+    @pyqtSlot(str)
+    def setExtruderForSelection(self, extruder_id: str) -> None:
+        operation = GroupedOperation()
+
+        nodes_to_change = []
+        for node in Selection.getAllSelectedObjects():
+            # Do not change any nodes that already have the right extruder set.
+            if node.callDecoration("getActiveExtruder") == extruder_id:
+                continue
+
+            # If the node is a group, apply the active extruder to all children of the group.
+            if node.callDecoration("isGroup"):
+                for grouped_node in BreadthFirstIterator(node):
+                    if grouped_node.callDecoration("getActiveExtruder") == extruder_id:
+                        continue
+
+                    if grouped_node.callDecoration("isGroup"):
+                        continue
+
+                    nodes_to_change.append(grouped_node)
+                continue
+
+            nodes_to_change.append(node)
+
+        if not nodes_to_change:
+            # If there are no changes to make, we still need to reset the selected extruders.
+            # This is a workaround for checked menu items being deselected while still being
+            # selected.
+            ExtruderManager.getInstance().resetSelectedObjectExtruders()
+            return
+
+        for node in nodes_to_change:
+            operation.addOperation(SetObjectExtruderOperation(node, extruder_id))
+        operation.push()
+
     def _openUrl(self, url):
-        QDesktopServices.openUrl(url)
+        QDesktopServices.openUrl(url)

cura/CuraApplication.py

@@ -26,6 +26,7 @@ from UM.Message import Message
 from UM.i18n import i18nCatalog
 from UM.Workspace.WorkspaceReader import WorkspaceReader
 from UM.Platform import Platform
+from UM.Decorators import deprecated
 
 from UM.Operations.AddSceneNodeOperation import AddSceneNodeOperation
 from UM.Operations.RemoveSceneNodeOperation import RemoveSceneNodeOperation
@@ -221,6 +222,7 @@ class CuraApplication(QtApplication):
 
         self.getController().getScene().sceneChanged.connect(self.updatePlatformActivity)
         self.getController().toolOperationStopped.connect(self._onToolOperationStopped)
+        self.getController().contextMenuRequested.connect(self._onContextMenuRequested)
 
         Resources.addType(self.ResourceTypes.QmlFiles, "qml")
         Resources.addType(self.ResourceTypes.Firmware, "firmware")
@@ -810,6 +812,7 @@ class CuraApplication(QtApplication):
 
     # Remove all selected objects from the scene.
     @pyqtSlot()
+    @deprecated("Moved to CuraActions", "2.6")
     def deleteSelection(self):
         if not self.getController().getToolsEnabled():
             return
@@ -830,6 +833,7 @@ class CuraApplication(QtApplication):
     ##  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
@@ -857,13 +861,22 @@ class CuraApplication(QtApplication):
     #   \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):
-        job = MultiplyObjectsJob(object_id, count, min_offset)
+        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
@@ -1323,3 +1336,13 @@ class CuraApplication(QtApplication):
         except Exception as e:
             Logger.log("e", "Could not check file %s: %s", file_url, e)
             return False
+
+    def _onContextMenuRequested(self, x: float, y: float) -> None:
+        # Ensure we select the object if we request a context menu over an object without having a selection.
+        if not Selection.hasSelection():
+            node = self.getController().getScene().findObject(self.getRenderer().getRenderPass("selection").getIdAtPosition(x, y))
+            if node:
+                while(node.getParent() and node.getParent().callDecoration("isGroup")):
+                    node = node.getParent()
+
+                Selection.add(node)

cura/MultiplyObjectsJob.py

@@ -24,9 +24,9 @@ from UM.Operations.AddSceneNodeOperation import AddSceneNodeOperation
 
 
 class MultiplyObjectsJob(Job):
-    def __init__(self, object_id, count, min_offset = 8):
+    def __init__(self, objects, count, min_offset = 8):
         super().__init__()
-        self._object_id = object_id
+        self._objects = objects
         self._count = count
         self._min_offset = min_offset
 
@@ -35,38 +35,42 @@ class MultiplyObjectsJob(Job):
                                  dismissable=False, progress=0)
         status_message.show()
         scene = Application.getInstance().getController().getScene()
-        node = scene.findObject(self._object_id)
 
-        if not node and self._object_id != 0:  # Workaround for tool handles overlapping the selected object
-            node = Selection.getSelectedObject(0)
-
-        # If object is part of a group, multiply group
-        current_node = node
-        while current_node.getParent() and current_node.getParent().callDecoration("isGroup"):
-            current_node = current_node.getParent()
+        total_progress = len(self._objects) * self._count
+        current_progress = 0
 
         root = scene.getRoot()
         arranger = Arrange.create(scene_root=root)
-        node_too_big = False
-        if node.getBoundingBox().width < 300 or node.getBoundingBox().depth < 300:
-            offset_shape_arr, hull_shape_arr = ShapeArray.fromNode(current_node, min_offset=self._min_offset)
-        else:
-            node_too_big = True
         nodes = []
-        found_solution_for_all = True
-        for i in range(self._count):
-            # We do place the nodes one by one, as we want to yield in between.
-            if not node_too_big:
-                node, solution_found = arranger.findNodePlacement(current_node, offset_shape_arr, hull_shape_arr)
-            if node_too_big or not solution_found:
-                found_solution_for_all = False
-                new_location = node.getPosition()
-                new_location = new_location.set(z = 100 - i * 20)
-                node.setPosition(new_location)
+        for node in self._objects:
+            # If object is part of a group, multiply group
+            current_node = node
+            while current_node.getParent() and current_node.getParent().callDecoration("isGroup"):
+                current_node = current_node.getParent()
+
+            node_too_big = False
+            if node.getBoundingBox().width < 300 or node.getBoundingBox().depth < 300:
+                offset_shape_arr, hull_shape_arr = ShapeArray.fromNode(current_node, min_offset=self._min_offset)
+            else:
+                node_too_big = True
+
+            found_solution_for_all = True
+            for i in range(self._count):
+                # We do place the nodes one by one, as we want to yield in between.
+                if not node_too_big:
+                    node, solution_found = arranger.findNodePlacement(current_node, offset_shape_arr, hull_shape_arr)
+                if node_too_big or not solution_found:
+                    found_solution_for_all = False
+                    new_location = node.getPosition()
+                    new_location = new_location.set(z = 100 - i * 20)
+                    node.setPosition(new_location)
+
+                nodes.append(node)
+                current_progress += 1
+                status_message.setProgress((current_progress / total_progress) * 100)
+                Job.yieldThread()
 
-            nodes.append(node)
             Job.yieldThread()
-            status_message.setProgress((i + 1) / self._count * 100)
 
         if nodes:
             op = GroupedOperation()

cura/Settings/ExtruderManager.py

@@ -8,12 +8,14 @@ from UM.Application import Application #To get the global container stack to fin
 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.InstanceContainer import InstanceContainer
 from UM.Settings.SettingFunction import SettingFunction
 from UM.Settings.ContainerStack import ContainerStack
 from UM.Settings.DefinitionContainer import DefinitionContainer
-from typing import Optional
+from typing import Optional, List
 
 ##  Manages all existing extruder stacks.
 #
@@ -34,10 +36,13 @@ class ExtruderManager(QObject):
         super().__init__(parent)
         self._extruder_trains = { } #Per machine, a dictionary of extruder container stack IDs.
         self._active_extruder_index = 0
+        self._selected_object_extruders = []
         Application.getInstance().globalContainerStackChanged.connect(self.__globalContainerStackChanged)
         self._global_container_stack_definition_id = None
         self._addCurrentMachineExtruders()
 
+        Selection.selectionChanged.connect(self.resetSelectedObjectExtruders)
+
     ##  Gets the unique identifier of the currently active extruder stack.
     #
     #   The currently active extruder stack is the stack that is currently being
@@ -117,6 +122,48 @@ class ExtruderManager(QObject):
         except IndexError:
             return ""
 
+    ## Emitted whenever the selectedObjectExtruders property changes.
+    selectedObjectExtrudersChanged = pyqtSignal()
+
+    ##  Provides a list of extruder IDs used by the current selected objects.
+    @pyqtProperty("QVariantList", notify = selectedObjectExtrudersChanged)
+    def selectedObjectExtruders(self) -> List[str]:
+        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 = []
+            for node in Selection.getAllSelectedObjects():
+                if node.callDecoration("isGroup"):
+                    for grouped_node in BreadthFirstIterator(node):
+                        if grouped_node.callDecoration("isGroup"):
+                            continue
+
+                        selected_nodes.append(grouped_node)
+                else:
+                    selected_nodes.append(node)
+
+            # Then, figure out which nodes are used by those selected nodes.
+            for node in selected_nodes:
+                extruder = node.callDecoration("getActiveExtruder")
+                if extruder:
+                    object_extruders.add(extruder)
+                else:
+                    global_stack = Application.getInstance().getGlobalContainerStack()
+                    object_extruders.add(self._extruder_trains[global_stack.getId()]["0"].getId())
+
+            self._selected_object_extruders = list(object_extruders)
+
+        return self._selected_object_extruders
+
+    ##  Reset the internal list used for the selectedObjectExtruders property
+    #
+    #   This will trigger a recalculation of the extruders used for the
+    #   selection.
+    def resetSelectedObjectExtruders(self) -> None:
+        self._selected_object_extruders = []
+        self.selectedObjectExtrudersChanged.emit()
+
     def getActiveExtruderStack(self) -> ContainerStack:
         global_container_stack = Application.getInstance().getGlobalContainerStack()
 
@@ -357,7 +404,8 @@ class ExtruderManager(QObject):
 
         #Get the extruders of all meshes in the scene.
         support_enabled = False
-        support_interface_enabled = False
+        support_bottom_enabled = False
+        support_roof_enabled = False
         scene_root = Application.getInstance().getController().getScene().getRoot()
         meshes = [node for node in DepthFirstIterator(scene_root) if type(node) is SceneNode and node.isSelectable()] #Only use the nodes that will be printed.
         for mesh in meshes:
@@ -370,18 +418,22 @@ class ExtruderManager(QObject):
             per_mesh_stack = mesh.callDecoration("getStack")
             if per_mesh_stack:
                 support_enabled |= per_mesh_stack.getProperty("support_enable", "value")
-                support_interface_enabled |= per_mesh_stack.getProperty("support_interface_enable", "value")
+                support_bottom_enabled |= per_mesh_stack.getProperty("support_bottom_enable", "value")
+                support_roof_enabled |= per_mesh_stack.getProperty("support_roof_enable", "value")
             else: #Take the setting from the build extruder stack.
                 extruder_stack = container_registry.findContainerStacks(id = extruder_stack_id)[0]
                 support_enabled |= extruder_stack.getProperty("support_enable", "value")
-                support_interface_enabled |= extruder_stack.getProperty("support_enable", "value")
+                support_bottom_enabled |= extruder_stack.getProperty("support_bottom_enable", "value")
+                support_roof_enabled |= extruder_stack.getProperty("support_roof_enable", "value")
 
         #The support extruders.
         if support_enabled:
             used_extruder_stack_ids.add(self.extruderIds[str(global_stack.getProperty("support_infill_extruder_nr", "value"))])
             used_extruder_stack_ids.add(self.extruderIds[str(global_stack.getProperty("support_extruder_nr_layer_0", "value"))])
-            if support_interface_enabled:
-                used_extruder_stack_ids.add(self.extruderIds[str(global_stack.getProperty("support_interface_extruder_nr", "value"))])
+            if support_bottom_enabled:
+                used_extruder_stack_ids.add(self.extruderIds[str(global_stack.getProperty("support_bottom_extruder_nr", "value"))])
+            if support_roof_enabled:
+                used_extruder_stack_ids.add(self.extruderIds[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":
@@ -444,6 +496,8 @@ class ExtruderManager(QObject):
             self.globalContainerStackDefinitionChanged.emit()
         self.activeExtruderChanged.emit()
 
+        self.resetSelectedObjectExtruders()
+
     ##  Adds the extruders of the currently active machine.
     def _addCurrentMachineExtruders(self) -> None:
         global_stack = Application.getInstance().getGlobalContainerStack()

cura/Settings/ExtrudersModel.py

@@ -1,7 +1,7 @@
 # Copyright (c) 2016 Ultimaker B.V.
 # Cura is released under the terms of the AGPLv3 or higher.
 
-from PyQt5.QtCore import Qt, pyqtSignal, pyqtProperty
+from PyQt5.QtCore import Qt, pyqtSignal, pyqtProperty, pyqtSlot
 
 import UM.Qt.ListModel
 from UM.Application import Application
@@ -33,6 +33,12 @@ class ExtrudersModel(UM.Qt.ListModel.ListModel):
     # The ID of the definition of the extruder.
     DefinitionRole = Qt.UserRole + 5
 
+    # The material of the extruder.
+    MaterialRole = Qt.UserRole + 6
+
+    # The variant of the extruder.
+    VariantRole = Qt.UserRole + 7
+
     ##  List of colours to display if there is no material or the material has no known
     #   colour.
     defaultColors = ["#ffc924", "#86ec21", "#22eeee", "#245bff", "#9124ff", "#ff24c8"]
@@ -49,6 +55,8 @@ class ExtrudersModel(UM.Qt.ListModel.ListModel):
         self.addRoleName(self.ColorRole, "color")
         self.addRoleName(self.IndexRole, "index")
         self.addRoleName(self.DefinitionRole, "definition")
+        self.addRoleName(self.MaterialRole, "material")
+        self.addRoleName(self.VariantRole, "variant")
 
         self._add_global = False
         self._simple_names = False
@@ -141,6 +149,7 @@ class ExtrudersModel(UM.Qt.ListModel.ListModel):
             for extruder in manager.getMachineExtruders(global_container_stack.getId()):
                 extruder_name = extruder.getName()
                 material = extruder.findContainer({ "type": "material" })
+                variant = extruder.findContainer({"type": "variant"})
                 position = extruder.getMetaDataEntry("position", default = "0")  # Get the position
                 try:
                     position = int(position)
@@ -156,7 +165,9 @@ class ExtrudersModel(UM.Qt.ListModel.ListModel):
                     "name": extruder_name,
                     "color": color,
                     "index": position,
-                    "definition": extruder.getBottom().getId()
+                    "definition": extruder.getBottom().getId(),
+                    "material": material.getName() if material else "",
+                    "variant": variant.getName() if variant else "",
                 }
                 items.append(item)
                 changed = True

cura/Settings/SetObjectExtruderOperation.py

@@ -0,0 +1,27 @@
+# Copyright (c) 2017 Ultimaker B.V.
+# Cura is released under the terms of the AGPLv3 or higher.
+
+from UM.Scene.SceneNode import SceneNode
+from UM.Operations.Operation import Operation
+
+from cura.Settings.SettingOverrideDecorator import SettingOverrideDecorator
+
+##  Simple operation to set the extruder a certain object should be printed with.
+class SetObjectExtruderOperation(Operation):
+    def __init__(self, node: SceneNode, extruder_id: str) -> None:
+        self._node = node
+        self._extruder_id = extruder_id
+        self._previous_extruder_id = None
+        self._decorator_added = False
+
+    def undo(self):
+        if self._previous_extruder_id:
+            self._node.callDecoration("setActiveExtruder", self._previous_extruder_id)
+
+    def redo(self):
+        stack = self._node.callDecoration("getStack") #Don't try to get the active extruder since it may be None anyway.
+        if not stack:
+            self._node.addDecorator(SettingOverrideDecorator())
+
+        self._previous_extruder_id = self._node.callDecoration("getActiveExtruder")
+        self._node.callDecoration("setActiveExtruder", self._extruder_id)

cura/Settings/SettingInheritanceManager.py

@@ -109,10 +109,13 @@ class SettingInheritanceManager(QObject):
                 self._settings_with_inheritance_warning.remove(key)
                 settings_with_inheritance_warning_changed = True
 
-            # Find the topmost parent (Assumed to be a category)
             parent = definitions[0].parent
-            while parent.parent is not None:
-                parent = parent.parent
+            # Find the topmost parent (Assumed to be a category)
+            if parent is not None:
+                while parent.parent is not None:
+                    parent = parent.parent
+            else:
+                parent = definitions[0]  # Already at a category
 
             if parent.key not in self._settings_with_inheritance_warning and has_overwritten_inheritance:
                 # Category was not in the list yet, so needs to be added now.

cura/Settings/SettingOverrideDecorator.py

@@ -109,6 +109,7 @@ class SettingOverrideDecorator(SceneNodeDecorator):
     def setActiveExtruder(self, extruder_stack_id):
         self._extruder_stack = extruder_stack_id
         self._updateNextStack()
+        ExtruderManager.getInstance().resetSelectedObjectExtruders()
         self.activeExtruderChanged.emit()
 
     def getStack(self):