diff --git a/cura/CuraApplication.py b/cura/CuraApplication.py index b73629775a..ca146b22d6 100644 --- a/cura/CuraApplication.py +++ b/cura/CuraApplication.py @@ -162,6 +162,7 @@ class CuraApplication(QtApplication): for file in self.getCommandLineOption("file", []): job = ReadMeshJob(os.path.abspath(file)) + job.finished.connect(self._onFileLoaded) job.start() self.exec_() @@ -447,3 +448,15 @@ class CuraApplication(QtApplication): def _onMessageActionTriggered(self, message, action): if action == "eject": self.getStorageDevice("LocalFileStorage").ejectRemovableDrive(message._sdcard) + + def _onFileLoaded(self, job): + mesh = job.getResult() + if mesh != None: + node = SceneNode() + + node.setSelectable(True) + node.setMeshData(mesh) + node.setName(os.path.basename(job.getFileName())) + + op = AddSceneNodeOperation(node, self.getController().getScene().getRoot()) + op.push() diff --git a/plugins/LayerView/LayerView.py b/plugins/LayerView/LayerView.py index 96ff102a14..f3580039c5 100644 --- a/plugins/LayerView/LayerView.py +++ b/plugins/LayerView/LayerView.py @@ -5,8 +5,11 @@ from UM.View.View import View from UM.View.Renderer import Renderer from UM.Scene.Iterator.DepthFirstIterator import DepthFirstIterator from UM.Resources import Resources +from UM.Event import Event, KeyEvent +from UM.Signal import Signal from UM.Scene.Selection import Selection from UM.Math.Color import Color +from . import LayerViewProxy ## View used to display g-code paths. class LayerView(View): @@ -15,6 +18,19 @@ class LayerView(View): self._material = None self._num_layers = 0 self._layer_percentage = 0 # what percentage of layers need to be shown (SLider gives value between 0 - 100) + self._proxy = LayerViewProxy.LayerViewProxy() + self._controller.getScene().sceneChanged.connect(self._onSceneChanged) + self._max_layers = 10 + self._current_layer_num = 10 + + def getCurrentLayer(self): + return self._current_layer_num + + def _onSceneChanged(self, node): + self.calculateMaxLayers() + + def getMaxLayers(self): + return self._max_layers def beginRendering(self): scene = self.getController().getScene() @@ -39,24 +55,69 @@ class LayerView(View): except AttributeError: continue - if self._layer_percentage < 100: - start = 0 - end_layer = round(len(layer_data.getLayers()) * (self._layer_percentage / 100)) - end = 0 + start = 0 + end = 0 - element_counts = layer_data.getElementCounts() - for layer, counts in element_counts.items(): - end += sum(counts) + element_counts = layer_data.getElementCounts() + for layer, counts in element_counts.items(): + end += sum(counts) + ## Hack to ensure the end is correct. Not quite sure what causes this + end += 2 * len(counts) - if layer >= end_layer: - break + if layer >= self._current_layer_num: + break + + renderer.queueNode(node, mesh = layer_data, material = self._material, mode = Renderer.RenderLines, start = start, end = end) - renderer.queueNode(node, mesh = layer_data, material = self._material, mode = Renderer.RenderLines, start = start, end = end, overlay = True) - else: - renderer.queueNode(node, mesh = layer_data, material = self._material, mode = Renderer.RenderLines, overlay = True) - def setLayer(self, value): - self._layer_percentage = value - + if self._current_layer_num != value: + self._current_layer_num = value + if self._current_layer_num < 0: + self._current_layer_num = 0 + if self._current_layer_num > self._max_layers: + self._current_layer_num = self._max_layers + self.currentLayerNumChanged.emit() + + currentLayerNumChanged = Signal() + + def calculateMaxLayers(self): + scene = self.getController().getScene() + renderer = self.getRenderer() + if renderer and self._material: + renderer.setRenderSelection(False) + self._old_max_layers = self._max_layers + ## Recalculate num max layers + new_max_layers = 0 + for node in DepthFirstIterator(scene.getRoot()): + if not node.render(renderer): + if node.getMeshData() and node.isVisible(): + try: + layer_data = node.getMeshData().layerData + except AttributeError: + continue + if new_max_layers < len(layer_data.getLayers()): + new_max_layers = len(layer_data.getLayers()) + + if new_max_layers > 0 and new_max_layers != self._old_max_layers: + self._max_layers = new_max_layers + self.maxLayersChanged.emit() + + # This makes sure we update the current layer + self.setLayer(int(self._max_layers * (self._current_layer_num / self._old_max_layers))) + + maxLayersChanged = Signal() + + ## Hackish way to ensure the proxy is already created, which ensures that the layerview.qml is already created + # as this caused some issues. + def getProxy(self, engine, script_engine): + return self._proxy + def endRendering(self): pass + + def event(self, event): + if event.type == Event.KeyPressEvent: + if event.key == KeyEvent.UpKey: + self.setLayer(self._current_layer_num + 1) + if event.key == KeyEvent.DownKey: + self.setLayer(self._current_layer_num - 1) diff --git a/plugins/LayerView/LayerView.qml b/plugins/LayerView/LayerView.qml index fc598bfb75..f1d78d78f9 100644 --- a/plugins/LayerView/LayerView.qml +++ b/plugins/LayerView/LayerView.qml @@ -20,10 +20,11 @@ Item anchors.right : parent.right orientation: Qt.Vertical minimumValue: 0; - maximumValue: 100; + maximumValue: UM.LayerView.numLayers; + stepSize: 1 - value: 100; - onValueChanged: UM.ActiveView.triggerAction("setLayer", value) + value: UM.LayerView.currentLayer + onValueChanged: UM.LayerView.setCurrentLayer(value) style: UM.Theme.styles.slider; } diff --git a/plugins/LayerView/LayerViewProxy.py b/plugins/LayerView/LayerViewProxy.py new file mode 100644 index 0000000000..b6a266233c --- /dev/null +++ b/plugins/LayerView/LayerViewProxy.py @@ -0,0 +1,44 @@ +from PyQt5.QtCore import QObject, pyqtSignal, pyqtSlot, pyqtProperty +from UM.Application import Application +import LayerView +class LayerViewProxy(QObject): + def __init__(self, parent = None): + super().__init__(parent) + self._current_layer = 0 + self._controller = Application.getInstance().getController() + self._controller.activeViewChanged.connect(self._onActiveViewChanged) + self._onActiveViewChanged() + + currentLayerChanged = pyqtSignal() + maxLayersChanged = pyqtSignal() + + @pyqtProperty(int, notify = maxLayersChanged) + def numLayers(self): + active_view = self._controller.getActiveView() + #print("num max layers " , active_view.getMaxLayers()) + return active_view.getMaxLayers() + #return 100 + + @pyqtProperty(int, notify = currentLayerChanged) + def currentLayer(self): + active_view = self._controller.getActiveView() + if type(active_view) == LayerView.LayerView.LayerView: + return active_view.getCurrentLayer() + + @pyqtSlot(int) + def setCurrentLayer(self, layer_num): + active_view = self._controller.getActiveView() + if type(active_view) == LayerView.LayerView.LayerView: + active_view.setLayer(layer_num) + + def _onLayerChanged(self): + self.currentLayerChanged.emit() + + def _onMaxLayersChanged(self): + self.maxLayersChanged.emit() + + def _onActiveViewChanged(self): + active_view = self._controller.getActiveView() + if type(active_view) == LayerView.LayerView.LayerView: + active_view.currentLayerNumChanged.connect(self._onLayerChanged) + active_view.maxLayersChanged.connect(self._onMaxLayersChanged) \ No newline at end of file diff --git a/plugins/LayerView/__init__.py b/plugins/LayerView/__init__.py index 93aa856175..eb3ba4cdbe 100644 --- a/plugins/LayerView/__init__.py +++ b/plugins/LayerView/__init__.py @@ -1,7 +1,8 @@ # Copyright (c) 2015 Ultimaker B.V. # Cura is released under the terms of the AGPLv3 or higher. -from . import LayerView +from . import LayerView, LayerViewProxy +from PyQt5.QtQml import qmlRegisterType, qmlRegisterSingletonType from UM.i18n import i18nCatalog catalog = i18nCatalog("cura") @@ -21,6 +22,10 @@ def getMetaData(): } } +def createLayerViewProxy(engine, script_engine): + return LayerViewProxy.LayerViewProxy() def register(app): + layer_view = LayerView.LayerView() + qmlRegisterSingletonType(LayerViewProxy.LayerViewProxy, "UM", 1, 0, "LayerView", layer_view.getProxy) return { "view": LayerView.LayerView() } diff --git a/resources/qml/Toolbar.qml b/resources/qml/Toolbar.qml index e24d929ed7..e7cb0788c5 100644 --- a/resources/qml/Toolbar.qml +++ b/resources/qml/Toolbar.qml @@ -14,6 +14,23 @@ Item { width: buttons.width; height: buttons.height + panel.height; + Rectangle { + id: activeItemBackground; + + anchors.bottom: parent.bottom; + + width: UM.Theme.sizes.button.width; + height: UM.Theme.sizes.button.height * 2; + + opacity: panelBackground.opacity; + + color: UM.Theme.colors.tool_panel_background + + function setActive(new_x) { + x = new_x; + } + } + RowLayout { id: buttons; @@ -34,6 +51,7 @@ Item { checkable: true; checked: model.active; + onCheckedChanged: if (checked) activeItemBackground.setActive(x); style: UM.Theme.styles.tool_button; @@ -42,21 +60,35 @@ Item { MouseArea { anchors.fill: parent; onClicked: parent.checked ? UM.Controller.setActiveTool(null) : UM.Controller.setActiveTool(model.id); + } - } + } } } - Loader { - id: panel + UM.AngledCornerRectangle { + id: panelBackground; anchors.left: parent.left; - anchors.right: parent.right; anchors.bottom: buttons.top; anchors.bottomMargin: UM.Theme.sizes.default_margin.height; - height: childrenRect.height; + width: panel.item ? panel.width + 2 * UM.Theme.sizes.default_margin.width : 0; + height: panel.item ? panel.height + 2 * UM.Theme.sizes.default_margin.height : 0; - source: UM.ActiveTool.valid ? UM.ActiveTool.activeToolPanel : ""; + opacity: panel.item ? 1 : 0 + Behavior on opacity { NumberAnimation { duration: 100 } } + + color: UM.Theme.colors.tool_panel_background; + cornerSize: width > 0 ? UM.Theme.sizes.default_margin.width : 0; + + Loader { + id: panel + + x: UM.Theme.sizes.default_margin.width; + y: UM.Theme.sizes.default_margin.height; + + source: UM.ActiveTool.valid ? UM.ActiveTool.activeToolPanel : ""; + } } } diff --git a/resources/themes/cura/styles.qml b/resources/themes/cura/styles.qml index dc2b80d2ad..b7db374da1 100644 --- a/resources/themes/cura/styles.qml +++ b/resources/themes/cura/styles.qml @@ -246,4 +246,32 @@ QtObject { } } } + + property Component text_field: Component { + TextFieldStyle { + textColor: UM.Theme.colors.setting_control_text; + font: UM.Theme.fonts.default; + + background: Rectangle + { + implicitHeight: control.height; + implicitWidth: control.width; + + border.width: 1; + border.color: UM.Theme.colors.setting_control_border; + + color: UM.Theme.colors.setting_validation_ok; + + Label { + anchors.right: parent.right; + anchors.rightMargin: UM.Theme.sizes.setting_unit_margin.width; + anchors.verticalCenter: parent.verticalCenter; + + text: control.unit ? control.unit : "" + color: UM.Theme.colors.setting_unit; + font: UM.Theme.fonts.default; + } + } + } + } } diff --git a/resources/themes/cura/theme.json b/resources/themes/cura/theme.json index a79636aece..eda2badd71 100644 --- a/resources/themes/cura/theme.json +++ b/resources/themes/cura/theme.json @@ -110,7 +110,9 @@ "save_button_text": [35, 35, 35, 255], "message": [205, 202, 201, 255], - "message_text": [35, 35, 35, 255] + "message_text": [35, 35, 35, 255], + + "tool_panel_background": [255, 255, 255, 255] }, "sizes": {