From d43554190877e9db8a503ddc4a54b0b560975eaa Mon Sep 17 00:00:00 2001 From: ChrisTerBeke Date: Fri, 6 Oct 2017 17:29:37 +0200 Subject: [PATCH 1/8] create separate layerslider component, fix updating when changing view --- plugins/LayerView/LayerSlider.qml | 273 ++++++++++++++++++++ plugins/LayerView/LayerView.qml | 383 ++++++++-------------------- plugins/LayerView/LayerViewProxy.py | 21 +- 3 files changed, 388 insertions(+), 289 deletions(-) create mode 100644 plugins/LayerView/LayerSlider.qml diff --git a/plugins/LayerView/LayerSlider.qml b/plugins/LayerView/LayerSlider.qml new file mode 100644 index 0000000000..eee8ebe5c3 --- /dev/null +++ b/plugins/LayerView/LayerSlider.qml @@ -0,0 +1,273 @@ +// Copyright (c) 2017 Ultimaker B.V. +// Cura is released under the terms of the LGPLv3 or higher. + +import QtQuick 2.2 +import QtQuick.Controls 1.2 +import QtQuick.Layouts 1.1 +import QtQuick.Controls.Styles 1.1 + +import UM 1.0 as UM +import Cura 1.0 as Cura + +Item { + id: sliderRoot + + // handle properties + property real handleSize: 10 + property real handleRadius: handleSize / 2 + property real minimumRangeHandleSize: handleSize / 2 + property color upperHandleColor: "black" + property color lowerHandleColor: "black" + property color rangeHandleColor: "black" + + // track properties + property real trackThickness: 4 // width of the slider track + property real trackRadius: trackThickness / 2 + property color trackColor: "white" + property real trackBorderWidth: 1 // width of the slider track border + property color trackBorderColor: "black" + + // value properties + property real maximumValue: 100 + property real minimumValue: 0 + property real minimumRange: 0 // minimum range allowed between min and max values + property bool roundValues: true + property real upperValue: maximumValue + property real lowerValue: minimumValue + + property bool layersVisible: true + + function getUpperValue () { + return upperHandle.getValue() + } + + function setUpperValue (value) { + console.log("setUpperValue", value) + upperHandle.setValue(value) + updateRangeHandle() + } + + function getLowerValue () { + return lowerHandle.getValue() + } + + function setLowerValue (value) { + console.log("setLowerValue", value) + lowerHandle.setValue(value) + updateRangeHandle() + } + + function updateRangeHandle () { + rangeHandle.height = lowerHandle.y - (upperHandle.y + upperHandle.height) + } + + // slider track + Rectangle { + id: track + + width: sliderRoot.trackThickness + height: sliderRoot.height - sliderRoot.handleSize + radius: sliderRoot.trackRadius + anchors.centerIn: sliderRoot + color: sliderRoot.trackColor + border.width: sliderRoot.trackBorderWidth + border.color: sliderRoot.trackBorderColor + visible: sliderRoot.layersVisible + } + + // Range handle + Item { + id: rangeHandle + + y: upperHandle.y + upperHandle.height + width: sliderRoot.handleSize + height: sliderRoot.minimumRangeHandleSize + anchors.horizontalCenter: sliderRoot.horizontalCenter + visible: sliderRoot.layersVisible + + // set the new value when dragging + // the range slider is only dragged when the upper and lower sliders collide + function onHandleDragged () { + upperHandle.y = y - upperHandle.height + lowerHandle.y = y + height + + var upperValue = sliderRoot.getUpperValue() + var lowerValue = upperValue - (sliderRoot.upperValue - sliderRoot.lowerValue) + + // update the Python values + // TODO: improve this? + UM.LayerView.setCurrentLayer(upperValue) + UM.LayerView.setMinimumLayer(lowerValue) + } + + Rectangle { + width: sliderRoot.trackThickness - 2 * sliderRoot.trackBorderWidth + height: parent.height + sliderRoot.handleSize + anchors.centerIn: parent + color: sliderRoot.rangeHandleColor + } + + MouseArea { + anchors.fill: parent + + drag { + target: parent + axis: Drag.YAxis + minimumY: upperHandle.height + maximumY: sliderRoot.height - (parent.heigth + lowerHandle.height) + } + + onPositionChanged: parent.onHandleDragged() + } + } + + // Upper handle + Rectangle { + id: upperHandle + + y: sliderRoot.height - (sliderRoot.minimumRangeHandleSize + 2 * sliderRoot.handleSize) + width: sliderRoot.handleSize + height: sliderRoot.handleSize + anchors.horizontalCenter: sliderRoot.horizontalCenter + radius: sliderRoot.handleRadius + color: sliderRoot.upperHandleColor + visible: sliderRoot.layersVisible + + function onHandleDragged () { + + console.log("upperhandle dragged") + + // don't allow the lower handle to be heigher than the upper handle + if (lowerHandle.y - (y + height) < sliderRoot.minimumRangeHandleSize) { + lowerHandle.y = y + height + sliderRoot.minimumRangeHandleSize + } + + // update the rangle handle + rangeHandle.height = lowerHandle.y - (y + height) + + // TODO: improve this? + UM.LayerView.setCurrentLayer(getValue()) + } + + // get the upper value based on the slider position + function getValue () { + var result = y / (sliderRoot.height - (2 * sliderRoot.handleSize + sliderRoot.minimumRangeHandleSize)) + result = sliderRoot.maximumValue + result * (sliderRoot.minimumValue - (sliderRoot.maximumValue - sliderRoot.minimumValue)) + result = sliderRoot.roundValues ? Math.round(result) : result + return result + } + + // set the slider position based on the upper value + function setValue (value) { + console.log("setValue", value) + var diff = (value - sliderRoot.maximumValue) / (sliderRoot.minimumValue - sliderRoot.maximumValue) + var newUpperYPosition = Math.round(diff * (sliderRoot.height - (2 * sliderRoot.handleSize + sliderRoot.minimumRangeHandleSize))) + y = newUpperYPosition + } + + // dragging + MouseArea { + anchors.fill: parent + + drag { + target: parent + axis: Drag.YAxis + minimumY: 0 + maximumY: sliderRoot.height - (2 * sliderRoot.handleSize + sliderRoot.minimumRangeHandleSize) + } + + onPositionChanged: parent.onHandleDragged() + } + +// UM.PointingRectangle { +// +// x: sliderRoot.width - UM.Theme.getSize("slider_layerview_background").width / 2 - width; +// y: Math.floor(((parent.y + parent.height) / 2) - (height / 2)); +// +// target: Qt.point(parent.width, (parent.y + parent.height) / 2) +// arrowSize: UM.Theme.getSize("default_arrow").width +// +// height: UM.Theme.getSize("slider_handle").height + UM.Theme.getSize("default_margin").height +// width: valueLabel.width + UM.Theme.getSize("default_margin").width +// Behavior on height { NumberAnimation { duration: 50; } } +// +// color: UM.Theme.getColor("tool_panel_background") +// borderColor: UM.Theme.getColor("lining") +// borderWidth: UM.Theme.getSize("default_lining").width +// visible: sliderRoot.layersVisible +// +// // Catch all mouse events (so 3D scene doesn't handle them) +// MouseArea { +// anchors.fill: parent +// } +// +// TextField { +// id: upperValueLabel +// +// property string maximumValue: sliderRoot.maximumValue + 1 +// +// text: sliderRoot.getUpperValue() + 1 +// horizontalAlignment: TextInput.AlignRight +// +// +// } +// } + } + + // Lower handle + Rectangle { + id: lowerHandle + + y: sliderRoot.height - sliderRoot.handleSize + width: parent.handleSize + height: parent.handleSize + anchors.horizontalCenter: parent.horizontalCenter + radius: sliderRoot.handleRadius + color: sliderRoot.lowerHandleColor + + visible: slider.layersVisible + + function onHandleDragged () { + + // don't allow the upper handle to be lower than the lower handle + if (y - (upperHandle.y + upperHandle.height) < sliderRoot.minimumRangeHandleSize) { + upperHandle.y = y - (upperHandle.heigth + sliderRoot.minimumRangeHandleSize) + } + + // update the range handle + rangeHandle.height = y - (upperHandle.y + upperHandle.height) + + // TODO: improve this? + UM.LayerView.setMinimumLayer(getValue()); + } + + // get the lower value from the current slider position + function getValue () { + var result = (y - (sliderRoot.handleSize + sliderRoot.minimumRangeHandleSize)) / (sliderRoot.height - (2 * sliderRoot.handleSize + sliderRoot.minimumRangeHandleSize)); + result = sliderRoot.maximumValue - sliderRoot.minimumRange + result * (sliderRoot.minimumValue - (sliderRoot.maximumValue - sliderRoot.minimumRange)) + result = sliderRoot.roundValues ? Math.round(result) : result + return result + } + + // set the slider position based on the lower value + function setValue (value) { + var diff = (value - sliderRoot.maximumValue) / (sliderRoot.minimumValue - sliderRoot.maximumValue) + var newLowerYPosition = Math.round((sliderRoot.handleSize + sliderRoot.minimumRangeHandleSize) + diff * (sliderRoot.height - (2 * sliderRoot.handleSize + sliderRoot.minimumRangeHandleSize))) + y = newLowerYPosition + } + + // dragging + MouseArea { + anchors.fill: parent + + drag { + target: parent + axis: Drag.YAxis + minimumY: upperHandle.height + sliderRoot.minimumRangeHandleSize + maximumY: sliderRoot.height - parent.height + } + + onPositionChanged: parent.onHandleDragged() + } + } +} diff --git a/plugins/LayerView/LayerView.qml b/plugins/LayerView/LayerView.qml index 7b2b7ac2c2..6bc7a23033 100755 --- a/plugins/LayerView/LayerView.qml +++ b/plugins/LayerView/LayerView.qml @@ -9,6 +9,8 @@ import QtQuick.Controls.Styles 1.1 import UM 1.0 as UM import Cura 1.0 as Cura +//import LayerSlider 1.0 + Item { id: base @@ -338,296 +340,121 @@ Item } } - Item - { + LayerSlider { id: slider - width: handleSize + + width: UM.Theme.getSize("slider_handle").width height: UM.Theme.getSize("layerview_menu_size").height - anchors.top: parent.bottom - anchors.topMargin: UM.Theme.getSize("slider_layerview_margin").height - anchors.right: layerViewMenu.right - anchors.rightMargin: UM.Theme.getSize("slider_layerview_margin").width - property real handleSize: UM.Theme.getSize("slider_handle").width - property real handleRadius: handleSize / 2 - property real minimumRangeHandleSize: UM.Theme.getSize("slider_handle").width / 2 - property real trackThickness: UM.Theme.getSize("slider_groove").width - property real trackRadius: trackThickness / 2 - property real trackBorderWidth: UM.Theme.getSize("default_lining").width - property color upperHandleColor: UM.Theme.getColor("slider_handle") - property color lowerHandleColor: UM.Theme.getColor("slider_handle") - property color rangeHandleColor: UM.Theme.getColor("slider_groove_fill") - property color trackColor: UM.Theme.getColor("slider_groove") - property color trackBorderColor: UM.Theme.getColor("slider_groove_border") - - property real maximumValue: UM.LayerView.numLayers - property real minimumValue: 0 - property real minimumRange: 0 - property bool roundValues: true - - property var activeHandle: upperHandle - property bool layersVisible: UM.LayerView.layerActivity && CuraApplication.platformActivity ? true : false - - function getUpperValueFromHandle() - { - var result = upperHandle.y / (height - (2 * handleSize + minimumRangeHandleSize)); - result = maximumValue + result * (minimumValue - (maximumValue - minimumRange)); - result = roundValues ? Math.round(result) | 0 : result; - return result; + anchors { + top: parent.bottom + topMargin: UM.Theme.getSize("slider_layerview_margin").height + right: layerViewMenu.right + rightMargin: UM.Theme.getSize("slider_layerview_margin").width } - function getLowerValueFromHandle() - { - var result = (lowerHandle.y - (handleSize + minimumRangeHandleSize)) / (height - (2 * handleSize + minimumRangeHandleSize)); - result = maximumValue - minimumRange + result * (minimumValue - (maximumValue - minimumRange)); - result = roundValues ? Math.round(result) : result; - return result; - } + // custom properties + upperValue: UM.LayerView.currentLayer + lowerValue: UM.LayerView.minimumLayer + maximumValue: UM.LayerView.numLayers + handleSize: UM.Theme.getSize("slider_handle").width + trackThickness: UM.Theme.getSize("slider_groove").width + trackColor: UM.Theme.getColor("slider_groove") + trackBorderColor: UM.Theme.getColor("slider_groove_border") + upperHandleColor: UM.Theme.getColor("slider_handle") + lowerHandleColor: UM.Theme.getColor("slider_handle") + rangeHandleColor: UM.Theme.getColor("slider_groove_fill") + layersVisible: UM.LayerView.layerActivity && CuraApplication.platformActivity ? true : false - function setUpperValue(value) - { - var value = (value - maximumValue) / (minimumValue - maximumValue); - var new_upper_y = Math.round(value * (height - (2 * handleSize + minimumRangeHandleSize))); - - if(new_upper_y != upperHandle.y) - { - upperHandle.y = new_upper_y; - } - rangeHandle.height = lowerHandle.y - (upperHandle.y + upperHandle.height); - } - - function setLowerValue(value) - { - var value = (value - maximumValue) / (minimumValue - maximumValue); - var new_lower_y = Math.round((handleSize + minimumRangeHandleSize) + value * (height - (2 * handleSize + minimumRangeHandleSize))); - - if(new_lower_y != lowerHandle.y) - { - lowerHandle.y = new_lower_y; - } - rangeHandle.height = lowerHandle.y - (upperHandle.y + upperHandle.height); - } - - Connections - { + // update values when layer data changes + Connections { target: UM.LayerView onMinimumLayerChanged: slider.setLowerValue(UM.LayerView.minimumLayer) onCurrentLayerChanged: slider.setUpperValue(UM.LayerView.currentLayer) } - Rectangle { - width: parent.trackThickness - height: parent.height - parent.handleSize - radius: parent.trackRadius - anchors.centerIn: parent - color: parent.trackColor - border.width: parent.trackBorderWidth; - border.color: parent.trackBorderColor; - visible: slider.layersVisible - } - - Item { - id: rangeHandle - y: upperHandle.y + upperHandle.height - width: parent.handleSize - height: parent.minimumRangeHandleSize - anchors.horizontalCenter: parent.horizontalCenter - - visible: slider.layersVisible - - property real value: UM.LayerView.currentLayer - function setValue(value) - { - var range = upperHandle.value - lowerHandle.value; - value = Math.min(value, slider.maximumValue); - value = Math.max(value, slider.minimumValue + range); - UM.LayerView.setCurrentLayer(value); - UM.LayerView.setMinimumLayer(value - range); - } - - Rectangle { - anchors.centerIn: parent - width: parent.parent.trackThickness - 2 * parent.parent.trackBorderWidth - height: parent.height + parent.parent.handleSize - color: parent.parent.rangeHandleColor - } - - MouseArea { - anchors.fill: parent - - drag.target: parent - drag.axis: Drag.YAxis - drag.minimumY: upperHandle.height - drag.maximumY: parent.parent.height - (parent.height + lowerHandle.height) - - onPressed: parent.parent.activeHandle = rangeHandle - onPositionChanged: - { - upperHandle.y = parent.y - upperHandle.height - lowerHandle.y = parent.y + parent.height - - var upper_value = slider.getUpperValueFromHandle(); - var lower_value = upper_value - (upperHandle.value - lowerHandle.value); - UM.LayerView.setCurrentLayer(upper_value); - UM.LayerView.setMinimumLayer(lower_value); - } - } - } - - Rectangle { - id: upperHandle - y: parent.height - (parent.minimumRangeHandleSize + 2 * parent.handleSize) - width: parent.handleSize - height: parent.handleSize - anchors.horizontalCenter: parent.horizontalCenter - radius: parent.handleRadius - color: parent.upperHandleColor - //border.width: UM.Theme.getSize("default_lining").width - //border.color: UM.Theme.getColor("slider_handle_border") - - visible: slider.layersVisible - - property real value: UM.LayerView.currentLayer - function setValue(value) - { - UM.LayerView.setCurrentLayer(value); - } - - MouseArea { - anchors.fill: parent - - drag.target: parent - drag.axis: Drag.YAxis - drag.minimumY: 0 - drag.maximumY: parent.parent.height - (2 * parent.parent.handleSize + parent.parent.minimumRangeHandleSize) - - onPressed: parent.parent.activeHandle = upperHandle - onPositionChanged: - { - if(lowerHandle.y - (upperHandle.y + upperHandle.height) < parent.parent.minimumRangeHandleSize) - { - lowerHandle.y = upperHandle.y + upperHandle.height + parent.parent.minimumRangeHandleSize; - } - rangeHandle.height = lowerHandle.y - (upperHandle.y + upperHandle.height); - - UM.LayerView.setCurrentLayer(slider.getUpperValueFromHandle()); - } - } - } - - Rectangle { - id: lowerHandle - y: parent.height - parent.handleSize - width: parent.handleSize - height: parent.handleSize - anchors.horizontalCenter: parent.horizontalCenter - radius: parent.handleRadius - color: parent.lowerHandleColor -// border.width: UM.Theme.getSize("default_lining").width -// border.color: UM.Theme.getColor("slider_handle_border") - - visible: slider.layersVisible - - property real value: UM.LayerView.minimumLayer - function setValue(value) - { - UM.LayerView.setMinimumLayer(value); - } - - MouseArea { - anchors.fill: parent - - drag.target: parent - drag.axis: Drag.YAxis - drag.minimumY: upperHandle.height + parent.parent.minimumRangeHandleSize - drag.maximumY: parent.parent.height - parent.height - - onPressed: parent.parent.activeHandle = lowerHandle - onPositionChanged: - { - if(lowerHandle.y - (upperHandle.y + upperHandle.height) < parent.parent.minimumRangeHandleSize) - { - upperHandle.y = lowerHandle.y - (upperHandle.height + parent.parent.minimumRangeHandleSize); - } - rangeHandle.height = lowerHandle.y - (upperHandle.y + upperHandle.height) - - UM.LayerView.setMinimumLayer(slider.getLowerValueFromHandle()); - } - } - } - - UM.PointingRectangle - { - x: parent.width - UM.Theme.getSize("slider_layerview_background").width / 2 - width; - y: Math.floor(slider.activeHandle.y + slider.activeHandle.height / 2 - height / 2); - - target: Qt.point(parent.width, slider.activeHandle.y + slider.activeHandle.height / 2) - arrowSize: UM.Theme.getSize("default_arrow").width - - height: UM.Theme.getSize("slider_handle").height + UM.Theme.getSize("default_margin").height - width: valueLabel.width + UM.Theme.getSize("default_margin").width - Behavior on height { NumberAnimation { duration: 50; } } - - color: UM.Theme.getColor("tool_panel_background") - borderColor: UM.Theme.getColor("lining") - borderWidth: UM.Theme.getSize("default_lining").width - - visible: slider.layersVisible - - MouseArea //Catch all mouse events (so scene doesnt handle them) - { - anchors.fill: parent - } - - TextField - { - id: valueLabel - property string maxValue: slider.maximumValue + 1 - text: slider.activeHandle.value + 1 - horizontalAlignment: TextInput.AlignRight; - onEditingFinished: - { - // Ensure that the cursor is at the first position. On some systems the text isn't fully visible - // Seems to have to do something with different dpi densities that QML doesn't quite handle. - // Another option would be to increase the size even further, but that gives pretty ugly results. - cursorPosition = 0; - if(valueLabel.text != '') - { - slider.activeHandle.setValue(valueLabel.text - 1); - } - } - validator: IntValidator { bottom: 1; top: slider.maximumValue + 1; } - - anchors.left: parent.left; - anchors.leftMargin: UM.Theme.getSize("default_margin").width / 2; - anchors.verticalCenter: parent.verticalCenter; - - width: Math.max(UM.Theme.getSize("line").width * maxValue.length + 2 * screenScaleFactor, 20 * screenScaleFactor); - style: TextFieldStyle - { - textColor: UM.Theme.getColor("setting_control_text"); - font: UM.Theme.getFont("default"); - background: Item { } - } - - Keys.onUpPressed: slider.activeHandle.setValue(slider.activeHandle.value + ((event.modifiers & Qt.ShiftModifier) ? 10 : 1)) - Keys.onDownPressed: slider.activeHandle.setValue(slider.activeHandle.value - ((event.modifiers & Qt.ShiftModifier) ? 10 : 1)) - } - - BusyIndicator - { - id: busyIndicator; - anchors.left: parent.right; - anchors.leftMargin: UM.Theme.getSize("default_margin").width / 2; - anchors.verticalCenter: parent.verticalCenter; - - width: UM.Theme.getSize("slider_handle").height; - height: width; - - running: UM.LayerView.busy; - visible: UM.LayerView.busy; - } + // make sure the slider handlers show the correct value after switching views + Component.onCompleted: { + slider.setLowerValue(UM.LayerView.minimumLayer) + slider.setUpperValue(UM.LayerView.currentLayer) } } + +// Item +// { + +// UM.PointingRectangle +// { +// x: parent.width - UM.Theme.getSize("slider_layerview_background").width / 2 - width; +// y: Math.floor(slider.activeHandle.y + slider.activeHandle.height / 2 - height / 2); +// +// target: Qt.point(parent.width, slider.activeHandle.y + slider.activeHandle.height / 2) +// arrowSize: UM.Theme.getSize("default_arrow").width +// +// height: UM.Theme.getSize("slider_handle").height + UM.Theme.getSize("default_margin").height +// width: valueLabel.width + UM.Theme.getSize("default_margin").width +// Behavior on height { NumberAnimation { duration: 50; } } +// +// color: UM.Theme.getColor("tool_panel_background") +// borderColor: UM.Theme.getColor("lining") +// borderWidth: UM.Theme.getSize("default_lining").width +// +// visible: slider.layersVisible +// +// MouseArea //Catch all mouse events (so scene doesnt handle them) +// { +// anchors.fill: parent +// } +// +// TextField +// { +// id: valueLabel +// property string maxValue: slider.maximumValue + 1 +// text: slider.activeHandle.value + 1 +// horizontalAlignment: TextInput.AlignRight; +// onEditingFinished: +// { +// // Ensure that the cursor is at the first position. On some systems the text isn't fully visible +// // Seems to have to do something with different dpi densities that QML doesn't quite handle. +// // Another option would be to increase the size even further, but that gives pretty ugly results. +// cursorPosition = 0; +// if(valueLabel.text != '') +// { +// slider.activeHandle.setValue(valueLabel.text - 1); +// } +// } +// validator: IntValidator { bottom: 1; top: slider.maximumValue + 1; } +// +// anchors.left: parent.left; +// anchors.leftMargin: UM.Theme.getSize("default_margin").width / 2; +// anchors.verticalCenter: parent.verticalCenter; +// +// width: Math.max(UM.Theme.getSize("line").width * maxValue.length + 2 * screenScaleFactor, 20 * screenScaleFactor); +// style: TextFieldStyle +// { +// textColor: UM.Theme.getColor("setting_control_text"); +// font: UM.Theme.getFont("default"); +// background: Item { } +// } +// +// Keys.onUpPressed: slider.activeHandle.setValue(slider.activeHandle.value + ((event.modifiers & Qt.ShiftModifier) ? 10 : 1)) +// Keys.onDownPressed: slider.activeHandle.setValue(slider.activeHandle.value - ((event.modifiers & Qt.ShiftModifier) ? 10 : 1)) +// } +// +// BusyIndicator +// { +// id: busyIndicator; +// anchors.left: parent.right; +// anchors.leftMargin: UM.Theme.getSize("default_margin").width / 2; +// anchors.verticalCenter: parent.verticalCenter; +// +// width: UM.Theme.getSize("slider_handle").height; +// height: width; +// +// running: UM.LayerView.busy; +// visible: UM.LayerView.busy; +// } +// } +// } } } diff --git a/plugins/LayerView/LayerViewProxy.py b/plugins/LayerView/LayerViewProxy.py index bc372aeaf8..4cf84117da 100644 --- a/plugins/LayerView/LayerViewProxy.py +++ b/plugins/LayerView/LayerViewProxy.py @@ -6,7 +6,7 @@ import LayerView class LayerViewProxy(QObject): - def __init__(self, parent = None): + def __init__(self, parent=None): super().__init__(parent) self._current_layer = 0 self._controller = Application.getInstance().getController() @@ -18,33 +18,33 @@ class LayerViewProxy(QObject): activityChanged = pyqtSignal() globalStackChanged = pyqtSignal() preferencesChanged = pyqtSignal() + busyChanged = pyqtSignal() - @pyqtProperty(bool, notify = activityChanged) + @pyqtProperty(bool, notify=activityChanged) def layerActivity(self): active_view = self._controller.getActiveView() if type(active_view) == LayerView.LayerView.LayerView: return active_view.getActivity() - @pyqtProperty(int, notify = maxLayersChanged) + @pyqtProperty(int, notify=maxLayersChanged) def numLayers(self): active_view = self._controller.getActiveView() if type(active_view) == LayerView.LayerView.LayerView: return active_view.getMaxLayers() - @pyqtProperty(int, notify = currentLayerChanged) + @pyqtProperty(int, notify=currentLayerChanged) def currentLayer(self): active_view = self._controller.getActiveView() if type(active_view) == LayerView.LayerView.LayerView: return active_view.getCurrentLayer() - @pyqtProperty(int, notify = currentLayerChanged) + @pyqtProperty(int, notify=currentLayerChanged) def minimumLayer(self): active_view = self._controller.getActiveView() if type(active_view) == LayerView.LayerView.LayerView: return active_view.getMinimumLayer() - busyChanged = pyqtSignal() - @pyqtProperty(bool, notify = busyChanged) + @pyqtProperty(bool, notify=busyChanged) def busy(self): active_view = self._controller.getActiveView() if type(active_view) == LayerView.LayerView.LayerView: @@ -52,12 +52,11 @@ class LayerViewProxy(QObject): return False - @pyqtProperty(bool, notify = preferencesChanged) + @pyqtProperty(bool, notify=preferencesChanged) def compatibilityMode(self): active_view = self._controller.getActiveView() if type(active_view) == LayerView.LayerView.LayerView: return active_view.getCompatibilityMode() - return False @pyqtSlot(int) @@ -78,7 +77,7 @@ class LayerViewProxy(QObject): if type(active_view) == LayerView.LayerView.LayerView: active_view.setLayerViewType(layer_view_type) - @pyqtSlot(result = int) + @pyqtSlot(result=int) def getLayerViewType(self): active_view = self._controller.getActiveView() if type(active_view) == LayerView.LayerView.LayerView: @@ -116,7 +115,7 @@ class LayerViewProxy(QObject): if type(active_view) == LayerView.LayerView.LayerView: active_view.setShowInfill(show) - @pyqtProperty(int, notify = globalStackChanged) + @pyqtProperty(int, notify=globalStackChanged) def extruderCount(self): active_view = self._controller.getActiveView() if type(active_view) == LayerView.LayerView.LayerView: From 48e938675fcfbb35f71daee5f588eb00c9fa6154 Mon Sep 17 00:00:00 2001 From: ChrisTerBeke Date: Mon, 9 Oct 2017 11:26:26 +0200 Subject: [PATCH 2/8] start adding back slider labels - CURA-4412 --- plugins/LayerView/LayerSlider.qml | 88 +++++++++++--------- plugins/LayerView/LayerSliderLabel.qml | 110 +++++++++++++++++++++++++ plugins/LayerView/LayerView.qml | 80 +----------------- 3 files changed, 159 insertions(+), 119 deletions(-) create mode 100644 plugins/LayerView/LayerSliderLabel.qml diff --git a/plugins/LayerView/LayerSlider.qml b/plugins/LayerView/LayerSlider.qml index eee8ebe5c3..bad4216d23 100644 --- a/plugins/LayerView/LayerSlider.qml +++ b/plugins/LayerView/LayerSlider.qml @@ -19,6 +19,7 @@ Item { property color upperHandleColor: "black" property color lowerHandleColor: "black" property color rangeHandleColor: "black" + property real handleLabelWidth: width // track properties property real trackThickness: 4 // width of the slider track @@ -42,7 +43,6 @@ Item { } function setUpperValue (value) { - console.log("setUpperValue", value) upperHandle.setValue(value) updateRangeHandle() } @@ -52,7 +52,6 @@ Item { } function setLowerValue (value) { - console.log("setLowerValue", value) lowerHandle.setValue(value) updateRangeHandle() } @@ -135,15 +134,13 @@ Item { function onHandleDragged () { - console.log("upperhandle dragged") - // don't allow the lower handle to be heigher than the upper handle if (lowerHandle.y - (y + height) < sliderRoot.minimumRangeHandleSize) { lowerHandle.y = y + height + sliderRoot.minimumRangeHandleSize } // update the rangle handle - rangeHandle.height = lowerHandle.y - (y + height) + sliderRoot.updateRangeHandle() // TODO: improve this? UM.LayerView.setCurrentLayer(getValue()) @@ -159,10 +156,15 @@ Item { // set the slider position based on the upper value function setValue (value) { - console.log("setValue", value) var diff = (value - sliderRoot.maximumValue) / (sliderRoot.minimumValue - sliderRoot.maximumValue) var newUpperYPosition = Math.round(diff * (sliderRoot.height - (2 * sliderRoot.handleSize + sliderRoot.minimumRangeHandleSize))) y = newUpperYPosition + + // update the rangle handle + sliderRoot.updateRangeHandle() + + // TODO: improve this? + UM.LayerView.setCurrentLayer(getValue()) } // dragging @@ -179,39 +181,22 @@ Item { onPositionChanged: parent.onHandleDragged() } -// UM.PointingRectangle { -// -// x: sliderRoot.width - UM.Theme.getSize("slider_layerview_background").width / 2 - width; -// y: Math.floor(((parent.y + parent.height) / 2) - (height / 2)); -// -// target: Qt.point(parent.width, (parent.y + parent.height) / 2) -// arrowSize: UM.Theme.getSize("default_arrow").width -// -// height: UM.Theme.getSize("slider_handle").height + UM.Theme.getSize("default_margin").height -// width: valueLabel.width + UM.Theme.getSize("default_margin").width -// Behavior on height { NumberAnimation { duration: 50; } } -// -// color: UM.Theme.getColor("tool_panel_background") -// borderColor: UM.Theme.getColor("lining") -// borderWidth: UM.Theme.getSize("default_lining").width -// visible: sliderRoot.layersVisible -// -// // Catch all mouse events (so 3D scene doesn't handle them) -// MouseArea { -// anchors.fill: parent -// } -// -// TextField { -// id: upperValueLabel -// -// property string maximumValue: sliderRoot.maximumValue + 1 -// -// text: sliderRoot.getUpperValue() + 1 -// horizontalAlignment: TextInput.AlignRight -// -// -// } -// } + LayerSliderLabel { + id: upperHandleLabel + + height: sliderRoot.handleSize + UM.Theme.getSize("default_margin").height + // width is calculated automatically from the input field width + x: (sliderRoot.width / 2 - (parent.width / 2)) - width + y: Math.floor(parent.y + parent.height / 2 - height / 2) + target: Qt.point(sliderRoot.width, parent.y + parent.height / 2) + visible: sliderRoot.layersVisible + + // custom properties + maximumValue: sliderRoot.maximumValue + value: sliderRoot.getUpperValue() + busy: UM.LayerView.busy + setValue: sliderRoot.setUpperValue // connect callback functions + } } // Lower handle @@ -238,7 +223,7 @@ Item { rangeHandle.height = y - (upperHandle.y + upperHandle.height) // TODO: improve this? - UM.LayerView.setMinimumLayer(getValue()); + UM.LayerView.setMinimumLayer(getValue()) } // get the lower value from the current slider position @@ -254,6 +239,12 @@ Item { var diff = (value - sliderRoot.maximumValue) / (sliderRoot.minimumValue - sliderRoot.maximumValue) var newLowerYPosition = Math.round((sliderRoot.handleSize + sliderRoot.minimumRangeHandleSize) + diff * (sliderRoot.height - (2 * sliderRoot.handleSize + sliderRoot.minimumRangeHandleSize))) y = newLowerYPosition + + // update the rangle handle + sliderRoot.updateRangeHandle() + + // TODO: improve this? + UM.LayerView.setMinimumLayer(getValue()) } // dragging @@ -269,5 +260,22 @@ Item { onPositionChanged: parent.onHandleDragged() } + + LayerSliderLabel { + id: lowerHandleLabel + + height: sliderRoot.handleSize + UM.Theme.getSize("default_margin").height + // width is calculated automatically from the input field width + x: (parent.x + (parent.width / 2)) - width - 100 + y: Math.floor(parent.y + height / 2) + target: Qt.point(sliderRoot.width, parent.y + parent.height / 2) + visible: sliderRoot.layersVisible + + // custom properties + maximumValue: sliderRoot.maximumValue + value: sliderRoot.getLowerValue() + busy: UM.LayerView.busy + setValue: sliderRoot.setLowerValue // connect callback functions + } } } diff --git a/plugins/LayerView/LayerSliderLabel.qml b/plugins/LayerView/LayerSliderLabel.qml new file mode 100644 index 0000000000..616af7e5be --- /dev/null +++ b/plugins/LayerView/LayerSliderLabel.qml @@ -0,0 +1,110 @@ +// Copyright (c) 2017 Ultimaker B.V. +// Cura is released under the terms of the LGPLv3 or higher. + +import QtQuick 2.2 +import QtQuick.Controls 1.2 +import QtQuick.Layouts 1.1 +import QtQuick.Controls.Styles 1.1 + +import UM 1.0 as UM +import Cura 1.0 as Cura + +Item { + id: sliderLabelRoot + + // custom properties + property var target // Qt.point + property real maximumValue: 100 + property real value: 0 + property var setValue // Function + property bool busy: false + + x: parent.x + y: parent.y + height: parent.height + visible: true + + UM.PointingRectangle { + x: sliderLabelRoot.x + y: sliderLabelRoot.y + target: sliderLabelRoot.target + arrowSize: UM.Theme.getSize("default_arrow").width + height: sliderLabelRoot.height + width: valueLabel.width + UM.Theme.getSize("default_margin").width + + color: UM.Theme.getColor("tool_panel_background") + borderColor: UM.Theme.getColor("lining") + borderWidth: UM.Theme.getSize("default_lining").width + + visible: sliderLabelRoot.visible + + Behavior on height { + NumberAnimation { + duration: 50 + } + } + + // catch all mouse events so they're not handled by underlying 3D scene + MouseArea { + anchors.fill: parent + } + + TextField { + id: valueLabel + + anchors { + left: parent.left + leftMargin: UM.Theme.getSize("default_margin").width / 2 + verticalCenter: parent.verticalCenter + } + + width: Math.max(UM.Theme.getSize("line").width * sliderLabelRoot.maximumValue.length + 2 * screenScaleFactor, 20 * screenScaleFactor) + + text: sliderLabelRoot.value + 1 // the current handle value, add 1 because layers is an array + horizontalAlignment: TextInput.AlignRight + + style: TextFieldStyle { + textColor: UM.Theme.getColor("setting_control_text") + font: UM.Theme.getFont("default") + background: Item { } + } + + onEditingFinished: { + + // Ensure that the cursor is at the first position. On some systems the text isn't fully visible + // Seems to have to do something with different dpi densities that QML doesn't quite handle. + // Another option would be to increase the size even further, but that gives pretty ugly results. + cursorPosition = 0 + + if (valueLabel.text != "") { + // -1 because we need to convert back to an array structure + sliderLabelRoot.setValue(parseInt(valueLabel.text) - 1) + } + } + + validator: IntValidator { + bottom: 1 + top: sliderLabelRoot.maximumValue + 1 // +1 because actual layers is an array + } + + Keys.onUpPressed: sliderLabelRoot.setValue(sliderLabelRoot.value + ((event.modifiers & Qt.ShiftModifier) ? 10 : 1)) + Keys.onDownPressed: sliderLabelRoot.setValue(sliderLabelRoot.value - ((event.modifiers & Qt.ShiftModifier) ? 10 : 1)) + } + + BusyIndicator { + id: busyIndicator + + anchors { + left: parent.right + leftMargin: UM.Theme.getSize("default_margin").width / 2 + verticalCenter: parent.verticalCenter + } + + width: sliderLabelRoot.height + height: width + + visible: sliderLabelRoot.busy + running: sliderLabelRoot.busy + } + } +} diff --git a/plugins/LayerView/LayerView.qml b/plugins/LayerView/LayerView.qml index 6bc7a23033..2a97bf8762 100755 --- a/plugins/LayerView/LayerView.qml +++ b/plugins/LayerView/LayerView.qml @@ -9,8 +9,6 @@ import QtQuick.Controls.Styles 1.1 import UM 1.0 as UM import Cura 1.0 as Cura -//import LayerSlider 1.0 - Item { id: base @@ -364,6 +362,7 @@ Item upperHandleColor: UM.Theme.getColor("slider_handle") lowerHandleColor: UM.Theme.getColor("slider_handle") rangeHandleColor: UM.Theme.getColor("slider_groove_fill") + handleLabelWidth: UM.Theme.getSize("slider_layerview_background").width layersVisible: UM.LayerView.layerActivity && CuraApplication.platformActivity ? true : false // update values when layer data changes @@ -379,82 +378,5 @@ Item slider.setUpperValue(UM.LayerView.currentLayer) } } - -// Item -// { - -// UM.PointingRectangle -// { -// x: parent.width - UM.Theme.getSize("slider_layerview_background").width / 2 - width; -// y: Math.floor(slider.activeHandle.y + slider.activeHandle.height / 2 - height / 2); -// -// target: Qt.point(parent.width, slider.activeHandle.y + slider.activeHandle.height / 2) -// arrowSize: UM.Theme.getSize("default_arrow").width -// -// height: UM.Theme.getSize("slider_handle").height + UM.Theme.getSize("default_margin").height -// width: valueLabel.width + UM.Theme.getSize("default_margin").width -// Behavior on height { NumberAnimation { duration: 50; } } -// -// color: UM.Theme.getColor("tool_panel_background") -// borderColor: UM.Theme.getColor("lining") -// borderWidth: UM.Theme.getSize("default_lining").width -// -// visible: slider.layersVisible -// -// MouseArea //Catch all mouse events (so scene doesnt handle them) -// { -// anchors.fill: parent -// } -// -// TextField -// { -// id: valueLabel -// property string maxValue: slider.maximumValue + 1 -// text: slider.activeHandle.value + 1 -// horizontalAlignment: TextInput.AlignRight; -// onEditingFinished: -// { -// // Ensure that the cursor is at the first position. On some systems the text isn't fully visible -// // Seems to have to do something with different dpi densities that QML doesn't quite handle. -// // Another option would be to increase the size even further, but that gives pretty ugly results. -// cursorPosition = 0; -// if(valueLabel.text != '') -// { -// slider.activeHandle.setValue(valueLabel.text - 1); -// } -// } -// validator: IntValidator { bottom: 1; top: slider.maximumValue + 1; } -// -// anchors.left: parent.left; -// anchors.leftMargin: UM.Theme.getSize("default_margin").width / 2; -// anchors.verticalCenter: parent.verticalCenter; -// -// width: Math.max(UM.Theme.getSize("line").width * maxValue.length + 2 * screenScaleFactor, 20 * screenScaleFactor); -// style: TextFieldStyle -// { -// textColor: UM.Theme.getColor("setting_control_text"); -// font: UM.Theme.getFont("default"); -// background: Item { } -// } -// -// Keys.onUpPressed: slider.activeHandle.setValue(slider.activeHandle.value + ((event.modifiers & Qt.ShiftModifier) ? 10 : 1)) -// Keys.onDownPressed: slider.activeHandle.setValue(slider.activeHandle.value - ((event.modifiers & Qt.ShiftModifier) ? 10 : 1)) -// } -// -// BusyIndicator -// { -// id: busyIndicator; -// anchors.left: parent.right; -// anchors.leftMargin: UM.Theme.getSize("default_margin").width / 2; -// anchors.verticalCenter: parent.verticalCenter; -// -// width: UM.Theme.getSize("slider_handle").height; -// height: width; -// -// running: UM.LayerView.busy; -// visible: UM.LayerView.busy; -// } -// } -// } } } From 5740af04bbbc4559706bfd1a55f4b560d07b13af Mon Sep 17 00:00:00 2001 From: ChrisTerBeke Date: Mon, 9 Oct 2017 14:19:21 +0200 Subject: [PATCH 3/8] continue layer slider labels - CURA-4412 --- plugins/LayerView/LayerSlider.qml | 4 +- plugins/LayerView/LayerSliderLabel.qml | 159 ++++++++++++------------- 2 files changed, 77 insertions(+), 86 deletions(-) diff --git a/plugins/LayerView/LayerSlider.qml b/plugins/LayerView/LayerSlider.qml index bad4216d23..518a05557a 100644 --- a/plugins/LayerView/LayerSlider.qml +++ b/plugins/LayerView/LayerSlider.qml @@ -186,8 +186,8 @@ Item { height: sliderRoot.handleSize + UM.Theme.getSize("default_margin").height // width is calculated automatically from the input field width - x: (sliderRoot.width / 2 - (parent.width / 2)) - width - y: Math.floor(parent.y + parent.height / 2 - height / 2) + x: parent.x - width // align with slider handle + y: parent.anchors.top - height // align with slider? handle target: Qt.point(sliderRoot.width, parent.y + parent.height / 2) visible: sliderRoot.layersVisible diff --git a/plugins/LayerView/LayerSliderLabel.qml b/plugins/LayerView/LayerSliderLabel.qml index 616af7e5be..875ec3ca01 100644 --- a/plugins/LayerView/LayerSliderLabel.qml +++ b/plugins/LayerView/LayerSliderLabel.qml @@ -9,7 +9,7 @@ import QtQuick.Controls.Styles 1.1 import UM 1.0 as UM import Cura 1.0 as Cura -Item { +UM.PointingRectangle { id: sliderLabelRoot // custom properties @@ -19,92 +19,83 @@ Item { property var setValue // Function property bool busy: false - x: parent.x - y: parent.y + target: sliderLabelRoot.target + arrowSize: UM.Theme.getSize("default_arrow").width height: parent.height + width: valueLabel.width + UM.Theme.getSize("default_margin").width + + color: UM.Theme.getColor("tool_panel_background") + borderColor: UM.Theme.getColor("lining") + borderWidth: UM.Theme.getSize("default_lining").width + visible: true - UM.PointingRectangle { - x: sliderLabelRoot.x - y: sliderLabelRoot.y - target: sliderLabelRoot.target - arrowSize: UM.Theme.getSize("default_arrow").width - height: sliderLabelRoot.height - width: valueLabel.width + UM.Theme.getSize("default_margin").width - - color: UM.Theme.getColor("tool_panel_background") - borderColor: UM.Theme.getColor("lining") - borderWidth: UM.Theme.getSize("default_lining").width - - visible: sliderLabelRoot.visible - - Behavior on height { - NumberAnimation { - duration: 50 - } - } - - // catch all mouse events so they're not handled by underlying 3D scene - MouseArea { - anchors.fill: parent - } - - TextField { - id: valueLabel - - anchors { - left: parent.left - leftMargin: UM.Theme.getSize("default_margin").width / 2 - verticalCenter: parent.verticalCenter - } - - width: Math.max(UM.Theme.getSize("line").width * sliderLabelRoot.maximumValue.length + 2 * screenScaleFactor, 20 * screenScaleFactor) - - text: sliderLabelRoot.value + 1 // the current handle value, add 1 because layers is an array - horizontalAlignment: TextInput.AlignRight - - style: TextFieldStyle { - textColor: UM.Theme.getColor("setting_control_text") - font: UM.Theme.getFont("default") - background: Item { } - } - - onEditingFinished: { - - // Ensure that the cursor is at the first position. On some systems the text isn't fully visible - // Seems to have to do something with different dpi densities that QML doesn't quite handle. - // Another option would be to increase the size even further, but that gives pretty ugly results. - cursorPosition = 0 - - if (valueLabel.text != "") { - // -1 because we need to convert back to an array structure - sliderLabelRoot.setValue(parseInt(valueLabel.text) - 1) - } - } - - validator: IntValidator { - bottom: 1 - top: sliderLabelRoot.maximumValue + 1 // +1 because actual layers is an array - } - - Keys.onUpPressed: sliderLabelRoot.setValue(sliderLabelRoot.value + ((event.modifiers & Qt.ShiftModifier) ? 10 : 1)) - Keys.onDownPressed: sliderLabelRoot.setValue(sliderLabelRoot.value - ((event.modifiers & Qt.ShiftModifier) ? 10 : 1)) - } - - BusyIndicator { - id: busyIndicator - - anchors { - left: parent.right - leftMargin: UM.Theme.getSize("default_margin").width / 2 - verticalCenter: parent.verticalCenter - } - - width: sliderLabelRoot.height - height: width - - visible: sliderLabelRoot.busy - running: sliderLabelRoot.busy + Behavior on height { + NumberAnimation { + duration: 50 } } + + // catch all mouse events so they're not handled by underlying 3D scene + MouseArea { + anchors.fill: parent + } + + TextField { + id: valueLabel + + anchors { + left: parent.left + leftMargin: UM.Theme.getSize("default_margin").width / 2 + verticalCenter: parent.verticalCenter + } + + width: Math.max(UM.Theme.getSize("line").width * sliderLabelRoot.maximumValue.length + 2 * screenScaleFactor, 20 * screenScaleFactor) + + text: sliderLabelRoot.value + 1 // the current handle value, add 1 because layers is an array + horizontalAlignment: TextInput.AlignRight + + style: TextFieldStyle { + textColor: UM.Theme.getColor("setting_control_text") + font: UM.Theme.getFont("default") + background: Item { } + } + + onEditingFinished: { + + // Ensure that the cursor is at the first position. On some systems the text isn't fully visible + // Seems to have to do something with different dpi densities that QML doesn't quite handle. + // Another option would be to increase the size even further, but that gives pretty ugly results. + cursorPosition = 0 + + if (valueLabel.text != "") { + // -1 because we need to convert back to an array structure + sliderLabelRoot.setValue(parseInt(valueLabel.text) - 1) + } + } + + validator: IntValidator { + bottom: 1 + top: sliderLabelRoot.maximumValue + 1 // +1 because actual layers is an array + } + + Keys.onUpPressed: sliderLabelRoot.setValue(sliderLabelRoot.value + ((event.modifiers & Qt.ShiftModifier) ? 10 : 1)) + Keys.onDownPressed: sliderLabelRoot.setValue(sliderLabelRoot.value - ((event.modifiers & Qt.ShiftModifier) ? 10 : 1)) + } + + BusyIndicator { + id: busyIndicator + + anchors { + left: parent.right + leftMargin: UM.Theme.getSize("default_margin").width / 2 + verticalCenter: parent.verticalCenter + } + + width: sliderLabelRoot.height + height: width + + visible: sliderLabelRoot.busy + running: sliderLabelRoot.busy + } } From 52eac6635f31252148ff7342ed05c93456828edc Mon Sep 17 00:00:00 2001 From: ChrisTerBeke Date: Mon, 9 Oct 2017 16:11:50 +0200 Subject: [PATCH 4/8] Improve layer slider label positions - CURA-4412 --- plugins/LayerView/LayerSlider.qml | 14 ++++++-------- plugins/LayerView/LayerSliderLabel.qml | 6 +++--- 2 files changed, 9 insertions(+), 11 deletions(-) diff --git a/plugins/LayerView/LayerSlider.qml b/plugins/LayerView/LayerSlider.qml index 518a05557a..1ed672f8e3 100644 --- a/plugins/LayerView/LayerSlider.qml +++ b/plugins/LayerView/LayerSlider.qml @@ -185,10 +185,9 @@ Item { id: upperHandleLabel height: sliderRoot.handleSize + UM.Theme.getSize("default_margin").height - // width is calculated automatically from the input field width - x: parent.x - width // align with slider handle - y: parent.anchors.top - height // align with slider? handle - target: Qt.point(sliderRoot.width, parent.y + parent.height / 2) + x: parent.x - width - UM.Theme.getSize("default_margin").width + anchors.verticalCenter: parent.verticalCenter + target: Qt.point(sliderRoot.width, y + height / 2) visible: sliderRoot.layersVisible // custom properties @@ -265,10 +264,9 @@ Item { id: lowerHandleLabel height: sliderRoot.handleSize + UM.Theme.getSize("default_margin").height - // width is calculated automatically from the input field width - x: (parent.x + (parent.width / 2)) - width - 100 - y: Math.floor(parent.y + height / 2) - target: Qt.point(sliderRoot.width, parent.y + parent.height / 2) + x: parent.x - width - UM.Theme.getSize("default_margin").width + anchors.verticalCenter: parent.verticalCenter + target: Qt.point(sliderRoot.width, y + height / 2) visible: sliderRoot.layersVisible // custom properties diff --git a/plugins/LayerView/LayerSliderLabel.qml b/plugins/LayerView/LayerSliderLabel.qml index 875ec3ca01..2b469b07eb 100644 --- a/plugins/LayerView/LayerSliderLabel.qml +++ b/plugins/LayerView/LayerSliderLabel.qml @@ -13,13 +13,12 @@ UM.PointingRectangle { id: sliderLabelRoot // custom properties - property var target // Qt.point property real maximumValue: 100 property real value: 0 property var setValue // Function property bool busy: false - target: sliderLabelRoot.target + target: Qt.point(parent.width, y + height / 2) arrowSize: UM.Theme.getSize("default_arrow").width height: parent.height width: valueLabel.width + UM.Theme.getSize("default_margin").width @@ -50,7 +49,8 @@ UM.PointingRectangle { verticalCenter: parent.verticalCenter } - width: Math.max(UM.Theme.getSize("line").width * sliderLabelRoot.maximumValue.length + 2 * screenScaleFactor, 20 * screenScaleFactor) + // width is based on text field contents, but never smaller than 20pts + width: 40 * screenScaleFactor text: sliderLabelRoot.value + 1 // the current handle value, add 1 because layers is an array horizontalAlignment: TextInput.AlignRight From e7e5e866116dd4c0151ca2414b43b288c4dd9859 Mon Sep 17 00:00:00 2001 From: ChrisTerBeke Date: Mon, 9 Oct 2017 17:00:03 +0200 Subject: [PATCH 5/8] Finish layer slider label positions and cursor manipulation - CURA-4412 --- plugins/LayerView/LayerSlider.qml | 28 ++++++++++++++------------ plugins/LayerView/LayerSliderLabel.qml | 2 -- 2 files changed, 15 insertions(+), 15 deletions(-) diff --git a/plugins/LayerView/LayerSlider.qml b/plugins/LayerView/LayerSlider.qml index 1ed672f8e3..e9efca0131 100644 --- a/plugins/LayerView/LayerSlider.qml +++ b/plugins/LayerView/LayerSlider.qml @@ -38,7 +38,7 @@ Item { property bool layersVisible: true - function getUpperValue () { + function getUpperValueFromSliderHandle () { return upperHandle.getValue() } @@ -47,7 +47,7 @@ Item { updateRangeHandle() } - function getLowerValue () { + function getLowerValueFromSliderHandle () { return lowerHandle.getValue() } @@ -90,7 +90,7 @@ Item { upperHandle.y = y - upperHandle.height lowerHandle.y = y + height - var upperValue = sliderRoot.getUpperValue() + var upperValue = sliderRoot.getUpperValueFromSliderHandle() var lowerValue = upperValue - (sliderRoot.upperValue - sliderRoot.lowerValue) // update the Python values @@ -156,15 +156,16 @@ Item { // set the slider position based on the upper value function setValue (value) { + + // TODO: improve this? + UM.LayerView.setCurrentLayer(value) + var diff = (value - sliderRoot.maximumValue) / (sliderRoot.minimumValue - sliderRoot.maximumValue) var newUpperYPosition = Math.round(diff * (sliderRoot.height - (2 * sliderRoot.handleSize + sliderRoot.minimumRangeHandleSize))) y = newUpperYPosition // update the rangle handle sliderRoot.updateRangeHandle() - - // TODO: improve this? - UM.LayerView.setCurrentLayer(getValue()) } // dragging @@ -192,7 +193,7 @@ Item { // custom properties maximumValue: sliderRoot.maximumValue - value: sliderRoot.getUpperValue() + value: sliderRoot.upperValue busy: UM.LayerView.busy setValue: sliderRoot.setUpperValue // connect callback functions } @@ -218,8 +219,8 @@ Item { upperHandle.y = y - (upperHandle.heigth + sliderRoot.minimumRangeHandleSize) } - // update the range handle - rangeHandle.height = y - (upperHandle.y + upperHandle.height) + // update the rangle handle + sliderRoot.updateRangeHandle() // TODO: improve this? UM.LayerView.setMinimumLayer(getValue()) @@ -235,15 +236,16 @@ Item { // set the slider position based on the lower value function setValue (value) { + + // TODO: improve this? + UM.LayerView.setMinimumLayer(value) + var diff = (value - sliderRoot.maximumValue) / (sliderRoot.minimumValue - sliderRoot.maximumValue) var newLowerYPosition = Math.round((sliderRoot.handleSize + sliderRoot.minimumRangeHandleSize) + diff * (sliderRoot.height - (2 * sliderRoot.handleSize + sliderRoot.minimumRangeHandleSize))) y = newLowerYPosition // update the rangle handle sliderRoot.updateRangeHandle() - - // TODO: improve this? - UM.LayerView.setMinimumLayer(getValue()) } // dragging @@ -271,7 +273,7 @@ Item { // custom properties maximumValue: sliderRoot.maximumValue - value: sliderRoot.getLowerValue() + value: sliderRoot.lowerValue busy: UM.LayerView.busy setValue: sliderRoot.setLowerValue // connect callback functions } diff --git a/plugins/LayerView/LayerSliderLabel.qml b/plugins/LayerView/LayerSliderLabel.qml index 2b469b07eb..5c477db29f 100644 --- a/plugins/LayerView/LayerSliderLabel.qml +++ b/plugins/LayerView/LayerSliderLabel.qml @@ -49,9 +49,7 @@ UM.PointingRectangle { verticalCenter: parent.verticalCenter } - // width is based on text field contents, but never smaller than 20pts width: 40 * screenScaleFactor - text: sliderLabelRoot.value + 1 // the current handle value, add 1 because layers is an array horizontalAlignment: TextInput.AlignRight From a2520b6b566afad0be43bb4a43d06eba6f73e2ba Mon Sep 17 00:00:00 2001 From: ChrisTerBeke Date: Tue, 10 Oct 2017 14:13:32 +0200 Subject: [PATCH 6/8] Fix maximum value range handle drag movement - CURA-4412 --- plugins/LayerView/LayerSlider.qml | 21 ++++++++++----------- 1 file changed, 10 insertions(+), 11 deletions(-) diff --git a/plugins/LayerView/LayerSlider.qml b/plugins/LayerView/LayerSlider.qml index e9efca0131..2f9330d50b 100644 --- a/plugins/LayerView/LayerSlider.qml +++ b/plugins/LayerView/LayerSlider.qml @@ -87,14 +87,14 @@ Item { // set the new value when dragging // the range slider is only dragged when the upper and lower sliders collide function onHandleDragged () { + upperHandle.y = y - upperHandle.height lowerHandle.y = y + height var upperValue = sliderRoot.getUpperValueFromSliderHandle() - var lowerValue = upperValue - (sliderRoot.upperValue - sliderRoot.lowerValue) + var lowerValue = sliderRoot.getLowerValueFromSliderHandle() - // update the Python values - // TODO: improve this? + // set both values after moving the handle position UM.LayerView.setCurrentLayer(upperValue) UM.LayerView.setMinimumLayer(lowerValue) } @@ -113,7 +113,7 @@ Item { target: parent axis: Drag.YAxis minimumY: upperHandle.height - maximumY: sliderRoot.height - (parent.heigth + lowerHandle.height) + maximumY: sliderRoot.height - (rangeHandle.height + lowerHandle.height) } onPositionChanged: parent.onHandleDragged() @@ -139,10 +139,10 @@ Item { lowerHandle.y = y + height + sliderRoot.minimumRangeHandleSize } - // update the rangle handle + // update the range handle sliderRoot.updateRangeHandle() - // TODO: improve this? + // set the new value after moving the handle position UM.LayerView.setCurrentLayer(getValue()) } @@ -157,14 +157,13 @@ Item { // set the slider position based on the upper value function setValue (value) { - // TODO: improve this? UM.LayerView.setCurrentLayer(value) var diff = (value - sliderRoot.maximumValue) / (sliderRoot.minimumValue - sliderRoot.maximumValue) var newUpperYPosition = Math.round(diff * (sliderRoot.height - (2 * sliderRoot.handleSize + sliderRoot.minimumRangeHandleSize))) y = newUpperYPosition - // update the rangle handle + // update the range handle sliderRoot.updateRangeHandle() } @@ -219,10 +218,10 @@ Item { upperHandle.y = y - (upperHandle.heigth + sliderRoot.minimumRangeHandleSize) } - // update the rangle handle + // update the range handle sliderRoot.updateRangeHandle() - // TODO: improve this? + // set the new value after moving the handle position UM.LayerView.setMinimumLayer(getValue()) } @@ -244,7 +243,7 @@ Item { var newLowerYPosition = Math.round((sliderRoot.handleSize + sliderRoot.minimumRangeHandleSize) + diff * (sliderRoot.height - (2 * sliderRoot.handleSize + sliderRoot.minimumRangeHandleSize))) y = newLowerYPosition - // update the rangle handle + // update the range handle sliderRoot.updateRangeHandle() } From c17493af3eb7c5f5aa9be5d8816b60ad49122752 Mon Sep 17 00:00:00 2001 From: ChrisTerBeke Date: Tue, 10 Oct 2017 14:23:57 +0200 Subject: [PATCH 7/8] Remove untrue comment line --- plugins/LayerView/LayerSlider.qml | 1 - 1 file changed, 1 deletion(-) diff --git a/plugins/LayerView/LayerSlider.qml b/plugins/LayerView/LayerSlider.qml index 2f9330d50b..261bb25c3f 100644 --- a/plugins/LayerView/LayerSlider.qml +++ b/plugins/LayerView/LayerSlider.qml @@ -85,7 +85,6 @@ Item { visible: sliderRoot.layersVisible // set the new value when dragging - // the range slider is only dragged when the upper and lower sliders collide function onHandleDragged () { upperHandle.y = y - upperHandle.height From ed8e5309b5785a0fa623f7707d5c27077d9df0fa Mon Sep 17 00:00:00 2001 From: "A.Sasin" Date: Tue, 10 Oct 2017 16:20:17 +0200 Subject: [PATCH 8/8] Remove Comment TODO CURA-4412 --- plugins/LayerView/LayerSlider.qml | 1 - 1 file changed, 1 deletion(-) diff --git a/plugins/LayerView/LayerSlider.qml b/plugins/LayerView/LayerSlider.qml index 261bb25c3f..74106f0bc8 100644 --- a/plugins/LayerView/LayerSlider.qml +++ b/plugins/LayerView/LayerSlider.qml @@ -235,7 +235,6 @@ Item { // set the slider position based on the lower value function setValue (value) { - // TODO: improve this? UM.LayerView.setMinimumLayer(value) var diff = (value - sliderRoot.maximumValue) / (sliderRoot.minimumValue - sliderRoot.maximumValue)