Merge branch 'master' into feature_intent

cura/CuraActions.py

@@ -3,15 +3,17 @@
 
 from PyQt5.QtCore import QObject, QUrl
 from PyQt5.QtGui import QDesktopServices
-from typing import List, cast
+from typing import List, Optional, cast
 
 from UM.Event import CallFunctionEvent
 from UM.FlameProfiler import pyqtSlot
+from UM.Math.Quaternion import Quaternion
 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.RotateOperation import RotateOperation
 from UM.Operations.TranslateOperation import TranslateOperation
 
 import cura.CuraApplication

cura/CuraApplication.py

@@ -69,6 +69,7 @@ from cura.Scene.BuildPlateDecorator import BuildPlateDecorator
 from cura.Scene.ConvexHullDecorator import ConvexHullDecorator
 from cura.Scene.CuraSceneController import CuraSceneController
 from cura.Scene.CuraSceneNode import CuraSceneNode
+from cura.Scene.GCodeListDecorator import GCodeListDecorator
 from cura.Scene.SliceableObjectDecorator import SliceableObjectDecorator
 from cura.Scene import ZOffsetDecorator
 
@@ -1344,7 +1345,13 @@ class CuraApplication(QtApplication):
         Logger.log("i", "Reloading all loaded mesh data.")
         nodes = []
         has_merged_nodes = False
+        gcode_filename = None  # type: Optional[str]
         for node in DepthFirstIterator(self.getController().getScene().getRoot()):
+            # Objects loaded from Gcode should also be included.
+            gcode_filename = node.callDecoration("getGcodeFileName")
+            if gcode_filename is not None:
+                break
+
             if not isinstance(node, CuraSceneNode) or not node.getMeshData():
                 if node.getName() == "MergedMesh":
                     has_merged_nodes = True
@@ -1352,6 +1359,11 @@ class CuraApplication(QtApplication):
 
             nodes.append(node)
 
+        # We can open only one gcode file at the same time. If the current view has a gcode file open, just reopen it
+        # for reloading.
+        if gcode_filename:
+            self._openFile(gcode_filename)
+
         if not nodes:
             return
 
@@ -1826,3 +1838,40 @@ class CuraApplication(QtApplication):
             return main_window.height()
         else:
             return 0
+
+    @pyqtSlot()
+    def deleteAll(self, only_selectable: bool = True) -> None:
+        super().deleteAll(only_selectable = only_selectable)
+
+        # Also remove nodes with LayerData
+        self._removeNodesWithLayerData(only_selectable = only_selectable)
+
+    def _removeNodesWithLayerData(self, only_selectable: bool = True) -> None:
+        Logger.log("i", "Clearing scene")
+        nodes = []
+        for node in DepthFirstIterator(self.getController().getScene().getRoot()):
+            if not isinstance(node, SceneNode):
+                continue
+            if not node.isEnabled():
+                continue
+            if (not node.getMeshData() and not node.callDecoration("getLayerData")) and not node.callDecoration("isGroup"):
+                continue  # Node that doesnt have a mesh and is not a group.
+            if only_selectable and not node.isSelectable():
+                continue  # Only remove nodes that are selectable.
+            if not node.callDecoration("isSliceable") and not node.callDecoration("getLayerData") and not node.callDecoration("isGroup"):
+                continue  # Grouped nodes don't need resetting as their parent (the group) is resetted)
+            nodes.append(node)
+        if nodes:
+            from UM.Operations.GroupedOperation import GroupedOperation
+            op = GroupedOperation()
+
+            for node in nodes:
+                from UM.Operations.RemoveSceneNodeOperation import RemoveSceneNodeOperation
+                op.addOperation(RemoveSceneNodeOperation(node))
+
+                # Reset the print information
+                self.getController().getScene().sceneChanged.emit(node)
+
+            op.push()
+            from UM.Scene.Selection import Selection
+            Selection.clear()

cura/PreviewPass.py

@@ -64,6 +64,7 @@ class PreviewPass(RenderPass):
                 self._shader.setUniformValue("u_ambientColor", [0.1, 0.1, 0.1, 1.0])
                 self._shader.setUniformValue("u_specularColor", [0.6, 0.6, 0.6, 1.0])
                 self._shader.setUniformValue("u_shininess", 20.0)
+                self._shader.setUniformValue("u_faceId", -1)  # Don't render any selected faces in the preview.
 
         if not self._non_printing_shader:
             if self._non_printing_shader:

cura/PrinterOutput/NetworkedPrinterOutputDevice.py

@@ -35,8 +35,6 @@ class NetworkedPrinterOutputDevice(PrinterOutputDevice):
     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
         self._timeout_time = 10  # After how many seconds of no response should a timeout occur?
 
         self._last_response_time = None     # type: Optional[float]
@@ -133,12 +131,6 @@ class NetworkedPrinterOutputDevice(PrinterOutputDevice):
 
             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 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:
             # Go out of timeout.
             if self._connection_state_before_timeout is not None:   # sanity check, but it should never be None here
@@ -317,7 +309,6 @@ class NetworkedPrinterOutputDevice(PrinterOutputDevice):
 
         self._manager = QNetworkAccessManager()
         self._manager.finished.connect(self._handleOnFinished)
-        self._last_manager_create_time = time()
         self._manager.authenticationRequired.connect(self._onAuthenticationRequired)
 
         if self._properties.get(b"temporary", b"false") != b"true":

cura/Scene/GCodeListDecorator.py

@@ -1,11 +1,18 @@
 from UM.Scene.SceneNodeDecorator import SceneNodeDecorator
-from typing import List
+from typing import List, Optional
 
 
 class GCodeListDecorator(SceneNodeDecorator):
     def __init__(self) -> None:
         super().__init__()
         self._gcode_list = []  # type: List[str]
+        self._filename = None  # type: Optional[str]
+
+    def getGcodeFileName(self) -> Optional[str]:
+        return self._filename
+
+    def setGcodeFileName(self, filename: str) -> None:
+        self._filename = filename
 
     def getGCodeList(self) -> List[str]:
         return self._gcode_list

cura/Settings/CuraContainerRegistry.py

@@ -241,12 +241,11 @@ class CuraContainerRegistry(ContainerRegistry):
 
                 # And check if the profile_definition matches either one (showing error if not):
                 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>!", "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)}
+                    Logger.log("d", "Profile {file_name} is for machine {profile_definition}, but the current active machine is {expected_machine_definition}. Changing profile's definition.".format(file_name = file_name, profile_definition = profile_definition, expected_machine_definition = expected_machine_definition))
+                    global_profile.setMetaDataEntry("definition", expected_machine_definition)
+                    for extruder_profile in extruder_profiles:
+                        extruder_profile.setMetaDataEntry("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)
                 quality_name = global_profile.getName()
                 quality_type = global_profile.getMetaDataEntry("quality_type")
 
@@ -314,9 +313,9 @@ class CuraContainerRegistry(ContainerRegistry):
                     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>!",
+                            "@info:status Don't translate the XML tag <filename>!",
                             "Failed to import profile from <filename>{0}</filename>:",
-                            file_name) + " <message>" + result + "</message>"}
+                            file_name) + " " + result}
 
                 return {"status": "ok", "message": catalog.i18nc("@info:status", "Successfully imported profile {0}", profile_or_list[0].getName())}
 

cura/Settings/GlobalStack.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2018 Ultimaker B.V.
+# Copyright (c) 2019 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
 
 from collections import defaultdict
@@ -8,7 +8,7 @@ import uuid
 
 from PyQt5.QtCore import pyqtProperty, pyqtSlot, pyqtSignal
 
-from UM.Decorators import override
+from UM.Decorators import deprecated, override
 from UM.MimeTypeDatabase import MimeType, MimeTypeDatabase
 from UM.Settings.ContainerStack import ContainerStack
 from UM.Settings.SettingInstance import InstanceState
@@ -61,12 +61,13 @@ class GlobalStack(CuraContainerStack):
     #
     #   \return The extruders registered with this stack.
     @pyqtProperty("QVariantMap", notify = extrudersChanged)
+    @deprecated("Please use extruderList instead.", "4.4")
     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_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")
@@ -302,6 +303,17 @@ class GlobalStack(CuraContainerStack):
             Logger.log("w", "Firmware file %s not found.", hex_file)
             return ""
 
+    def getName(self) -> str:
+        return self._metadata.get("group_name", self._metadata.get("name", ""))
+
+    def setName(self, name: "str") -> None:
+        super().setName(name)
+
+    nameChanged = pyqtSignal()
+    name = pyqtProperty(str, fget=getName, fset=setName, notify=nameChanged)
+
+
+
 ## private:
 global_stack_mime = MimeType(
     name = "application/x-cura-globalstack",

cura/Settings/MachineManager.py

@@ -1375,19 +1375,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
-        metadata_filter = {"group_id": self._global_container_stack.getMetaDataEntry("group_id"),
-                           "um_network_key": self.activeMachineNetworkKey(),
-                           }
+        metadata_filter = {"group_id": self._global_container_stack.getMetaDataEntry("group_id")}
         new_machine = self.getMachine(machine_definition_id, metadata_filter = metadata_filter)
         # 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("group_id", self._global_container_stack.getMetaDataEntry("group_id"))
-            new_machine.setMetaDataEntry("um_network_key", self.activeMachineNetworkKey())
-            new_machine.setMetaDataEntry("group_name", self.activeMachineNetworkGroupName)
-            new_machine.setMetaDataEntry("connection_type", self._global_container_stack.getMetaDataEntry("connection_type"))
+            
+            for metadata_key in self._global_container_stack.getMetaData():
+                if metadata_key in new_machine.getMetaData():
+                    continue  # Don't copy the already preset stuff.
+                new_machine.setMetaDataEntry(metadata_key, self._global_container_stack.getMetaDataEntry(metadata_key))
         else:
             Logger.log("i", "Found a %s with the key %s. Let's use it!", machine_name, self.activeMachineNetworkKey())
 

cura/Settings/PerObjectContainerStack.py

@@ -12,6 +12,10 @@ from .CuraContainerStack import CuraContainerStack
 
 
 class PerObjectContainerStack(CuraContainerStack):
+    def isDirty(self):
+        # This stack should never be auto saved, so always return that there is nothing to save. 
+        return False
+
     @override(CuraContainerStack)
     def getProperty(self, key: str, property_name: str, context: Optional[PropertyEvaluationContext] = None) -> Any:
         if context is None: