From e02e2bde8d242a3b788d9e53d9428927239fa03c Mon Sep 17 00:00:00 2001 From: Ghostkeeper Date: Thu, 26 May 2016 16:35:34 +0200 Subject: [PATCH 1/4] Remove semicolon at the end of the line --- .../CuraEngineBackend/CuraEngineBackend.py | 42 +++++++++---------- 1 file changed, 21 insertions(+), 21 deletions(-) diff --git a/plugins/CuraEngineBackend/CuraEngineBackend.py b/plugins/CuraEngineBackend/CuraEngineBackend.py index d088288391..c9a0efbbcb 100644 --- a/plugins/CuraEngineBackend/CuraEngineBackend.py +++ b/plugins/CuraEngineBackend/CuraEngineBackend.py @@ -134,26 +134,26 @@ class CuraEngineBackend(Backend): self._process_layers_job.abort() self._process_layers_job = None - #Don't slice if there is a setting with an error value. - stack = Application.getInstance().getGlobalContainerStack() - for key in stack.getAllKeys(): - validation_state = stack.getProperty(key, "validationState") - #Only setting instances have a validation state, so settings which - #are not overwritten by any instance will have none. The property - #then, and only then, evaluates to None. We make the assumption that - #the definition defines the setting with a default value that is - #valid. Therefore we can allow both ValidatorState.Valid and None as - #allowable validation states. - #TODO: This assumption is wrong! If the definition defines an inheritance function that through inheritance evaluates to a disallowed value, a setting is still invalid even though it's default! - #TODO: Therefore we must also validate setting definitions. - if validation_state != None and validation_state != ValidatorState.Valid: - Logger.log("w", "Setting %s is not valid, but %s. Aborting slicing.", key, validation_state) - if self._message: #Hide any old message before creating a new one. - self._message.hide() - self._message = None - self._message = Message(catalog.i18nc("@info:status", "Unable to slice. Please check your setting values for errors.")) - self._message.show() - return + # #Don't slice if there is a setting with an error value. + # stack = Application.getInstance().getGlobalContainerStack() + # for key in stack.getAllKeys(): + # validation_state = stack.getProperty(key, "validationState") + # #Only setting instances have a validation state, so settings which + # #are not overwritten by any instance will have none. The property + # #then, and only then, evaluates to None. We make the assumption that + # #the definition defines the setting with a default value that is + # #valid. Therefore we can allow both ValidatorState.Valid and None as + # #allowable validation states. + # #TODO: This assumption is wrong! If the definition defines an inheritance function that through inheritance evaluates to a disallowed value, a setting is still invalid even though it's default! + # #TODO: Therefore we must also validate setting definitions. + # if validation_state != None and validation_state != ValidatorState.Valid: + # Logger.log("w", "Setting %s is not valid, but %s. Aborting slicing.", key, validation_state) + # if self._message: #Hide any old message before creating a new one. + # self._message.hide() + # self._message = None + # self._message = Message(catalog.i18nc("@info:status", "Unable to slice. Please check your setting values for errors.")) + # self._message.show() + # return self.processingProgress.emit(0.0) self.backendStateChange.emit(BackendState.NOT_STARTED) @@ -168,7 +168,7 @@ class CuraEngineBackend(Backend): self.slicingStarted.emit() slice_message = self._socket.createMessage("cura.proto.Slice") - settings_message = self._socket.createMessage("cura.proto.SettingList"); + settings_message = self._socket.createMessage("cura.proto.SettingList") self._start_slice_job = StartSliceJob.StartSliceJob(slice_message, settings_message) self._start_slice_job.start() self._start_slice_job.finished.connect(self._onStartSliceCompleted) From c01e7144d16511148db002a0316ae077e176ca0a Mon Sep 17 00:00:00 2001 From: fieldOfView Date: Thu, 26 May 2016 18:06:40 +0200 Subject: [PATCH 2/4] Consistently change the spelling of bounding box bounding box, bounding_box, boundingBox --- cura/CuraApplication.py | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/cura/CuraApplication.py b/cura/CuraApplication.py index 9691b638a1..48f283f7f1 100644 --- a/cura/CuraApplication.py +++ b/cura/CuraApplication.py @@ -111,7 +111,7 @@ class CuraApplication(QtApplication): self._i18n_catalog = None self._previous_active_tool = None self._platform_activity = False - self._scene_boundingbox = AxisAlignedBox() + self._scene_bounding_box = AxisAlignedBox() self._job_name = None self._center_after_select = False self._camera_animation = None @@ -384,26 +384,26 @@ class CuraApplication(QtApplication): @pyqtProperty(str, notify = sceneBoundingBoxChanged) def getSceneBoundingBoxString(self): - return self._i18n_catalog.i18nc("@info", "%(width).1f x %(depth).1f x %(height).1f mm") % {'width' : self._scene_boundingbox.width.item(), 'depth': self._scene_boundingbox.depth.item(), 'height' : self._scene_boundingbox.height.item()} + return self._i18n_catalog.i18nc("@info", "%(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()} def updatePlatformActivity(self, node = None): count = 0 - scene_boundingbox = None + scene_bounding_box = None for node in DepthFirstIterator(self.getController().getScene().getRoot()): if type(node) is not SceneNode or not node.getMeshData(): continue count += 1 - if not scene_boundingbox: - scene_boundingbox = copy.deepcopy(node.getBoundingBox()) + if not scene_bounding_box: + scene_bounding_box = copy.deepcopy(node.getBoundingBox()) else: - scene_boundingbox += node.getBoundingBox() + scene_bounding_box += node.getBoundingBox() - if not scene_boundingbox: - scene_boundingbox = AxisAlignedBox() + if not scene_bounding_box: + scene_bounding_box = AxisAlignedBox() - if repr(self._scene_boundingbox) != repr(scene_boundingbox): - self._scene_boundingbox = scene_boundingbox + if repr(self._scene_bounding_box) != repr(scene_bounding_box): + self._scene_bounding_box = scene_bounding_box self.sceneBoundingBoxChanged.emit() self._platform_activity = True if count > 0 else False From 53661b27393395183aa69889485baab40c385e32 Mon Sep 17 00:00:00 2001 From: fieldOfView Date: Thu, 26 May 2016 22:18:34 +0200 Subject: [PATCH 3/4] Ensure a machine gets a unique names when adding or renaming a machine CURA-1606 --- cura/MachineManagerModel.py | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/cura/MachineManagerModel.py b/cura/MachineManagerModel.py index 8354f3a140..64990f9ab7 100644 --- a/cura/MachineManagerModel.py +++ b/cura/MachineManagerModel.py @@ -5,6 +5,8 @@ from UM.Preferences import Preferences import UM.Settings +import re + class MachineManagerModel(QObject): def __init__(self, parent = None): super().__init__(parent) @@ -64,6 +66,7 @@ class MachineManagerModel(QObject): definitions = UM.Settings.ContainerRegistry.getInstance().findDefinitionContainers(id=definition_id) if definitions: definition = definitions[0] + name = self._uniqueMachineName(name, definition.getName()) new_global_stack = UM.Settings.ContainerStack(name) new_global_stack.addMetaDataEntry("type", "machine") @@ -127,6 +130,25 @@ class MachineManagerModel(QObject): Application.getInstance().setGlobalContainerStack(new_global_stack) + # Create a name that is not empty and unique + def _uniqueMachineName(self, name, fallback_name): + name = name.strip() + num_check = re.compile("(.*?)\s*#\d$").match(name) + if(num_check): + name = num_check.group(1) + if name == "": + name = fallback_name + unique_name = name + i = 1 + + #Check both the id and the name, because they may not be the same and it is better if they are both unique + while UM.Settings.ContainerRegistry.getInstance().findContainers(None, id = unique_name) or + UM.Settings.ContainerRegistry.getInstance().findContainers(None, name = unique_name): + i = i + 1 + unique_name = "%s #%d" % (name, i) + + return unique_name + @pyqtProperty(str, notify = globalContainerChanged) def activeMachineName(self): if self._global_container_stack: @@ -239,6 +261,7 @@ class MachineManagerModel(QObject): def renameMachine(self, machine_id, new_name): containers = UM.Settings.ContainerRegistry.getInstance().findContainerStacks(id = machine_id) if containers: + new_name = self._uniqueMachineName(new_name, containers[0].getBottom().getName()) containers[0].setName(new_name) @pyqtSlot(str) From b60e704aa6cfa86cb8c7b088ca8b94943affae06 Mon Sep 17 00:00:00 2001 From: fieldOfView Date: Thu, 26 May 2016 22:29:21 +0200 Subject: [PATCH 4/4] Fix typo CURA-1606 --- cura/MachineManagerModel.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/cura/MachineManagerModel.py b/cura/MachineManagerModel.py index 64990f9ab7..11cb55d2b4 100644 --- a/cura/MachineManagerModel.py +++ b/cura/MachineManagerModel.py @@ -142,8 +142,8 @@ class MachineManagerModel(QObject): i = 1 #Check both the id and the name, because they may not be the same and it is better if they are both unique - while UM.Settings.ContainerRegistry.getInstance().findContainers(None, id = unique_name) or - UM.Settings.ContainerRegistry.getInstance().findContainers(None, name = unique_name): + while UM.Settings.ContainerRegistry.getInstance().findContainers(None, id = unique_name) or \ + UM.Settings.ContainerRegistry.getInstance().findContainers(None, name = unique_name): i = i + 1 unique_name = "%s #%d" % (name, i)