Very early KDE 6 release.

plasma/shells/org.kde.plasma.desktop/configuration_old/panelconfiguration/PanelRepresentation.qml

@@ -0,0 +1,174 @@
+import QtQuick
+import QtQuick.Layouts
+
+import org.kde.plasma.components as PC3
+import org.kde.plasma.core as PlasmaCore
+import org.kde.plasma.extras as PlasmaExtras
+import org.kde.ksvg as KSvg
+import org.kde.plasma.shell.panel as Panel
+import org.kde.kirigami as Kirigami
+
+Item {
+    id: root
+
+    property string text
+    property /*Qt::Alignment*/int alignment: Qt.AlignHCenter | Qt.AlignBottom
+    property string tooltip
+
+    property bool isVertical: false
+    property bool checked: false
+    property bool windowVisible: false
+    property bool panelVisible: true
+    property bool translucentPanel: false
+    property bool sunkenPanel: false
+    property bool adaptivePanel: false
+    property bool fillAvailable: false
+    property int floatingGap: 0
+    property int windowZ: 0
+    property var mainIconSource: null
+    property int screenHeight: Math.round(screenRect.height / 2)
+
+    readonly property bool iconAndLabelsShouldlookSelected: checked || mouseArea.pressed
+
+    signal clicked()
+
+    implicitHeight: mainItem.height
+    implicitWidth: mainItem.width
+
+    PC3.ToolTip {
+        text: root.tooltip
+        visible: mouseArea.containsMouse && text.length > 0
+    }
+
+    PlasmaExtras.Highlight {
+        anchors.fill: parent
+        anchors.margins: -Kirigami.Units.smallSpacing
+        hovered: mouseArea.containsMouse
+        pressed: root.iconAndLabelsShouldlookSelected
+    }
+
+    MouseArea {
+        id: mouseArea
+        anchors.fill: parent
+        hoverEnabled: true
+        onClicked: root.clicked()
+    }
+
+    ColumnLayout {
+        id: mainItem
+        spacing: Kirigami.Units.smallSpacing
+        Rectangle {
+            id: screenRect
+
+            Layout.alignment: Qt.AlignHCenter
+            implicitWidth: Math.round(Math.min(Kirigami.Units.gridUnit * 6, Screen.width * 0.1))
+            implicitHeight: Math.round(Math.min(Kirigami.Units.gridUnit * 4, Screen.width * 0.1))
+            color: Qt.tint(Kirigami.Theme.backgroundColor, Qt.rgba(1, 1, 1, 0.3))
+            border.color: Kirigami.Theme.highlightColor
+            radius: Kirigami.Units.cornerRadius
+            clip: root.sunkenPanel
+
+            RowLayout {
+                anchors.fill: parent
+                Rectangle {
+                    id: panelImage
+
+                    implicitWidth: root.isVertical ? Math.round(parent.width / 6) : Math.round(parent.width * (root.fillAvailable ? 1 : 0.8))
+                    implicitHeight: root.isVertical ? Math.round(parent.height * (root.fillAvailable ? 1 : 0.8)) : Math.round(parent.height / 4)
+                    Layout.alignment: root.alignment
+                    Layout.bottomMargin: root.sunkenPanel * -Math.round(height / 2) + root.floatingGap
+                    color: root.translucentPanel ? screenRect.color : Kirigami.Theme.backgroundColor
+                    opacity: root.translucentPanel ? 0.8 : 1.0
+                    border.color: "transparent"
+                    visible: root.panelVisible
+                    clip: root.adaptivePanel
+                    radius: Kirigami.Units.cornerRadius
+
+                    z: 1
+
+                    Loader {
+                        id: horizontalAdaptivePanelLoader
+                        active: root.adaptivePanel && !root.isVertical
+                        sourceComponent: Rectangle {
+                            anchors.verticalCenter: parent.verticalCenter
+                            anchors.left: parent.left
+                            anchors.leftMargin: Math.round(panelImage.width / 3)
+                            color: Qt.lighter(screenRect.color)
+                            border.color: Kirigami.Theme.highlightColor
+                            width: panelImage.width
+                            height: Math.round(panelImage.height * 4)
+                            radius: Math.round(height / 2)
+                            rotation: 45
+                        }
+                    }
+
+                    Loader {
+                        id: verticalAdaptivePanelLoader
+                        active: root.adaptivePanel && root.isVertical
+                        sourceComponent: Rectangle {
+                            anchors.horizontalCenter: parent.horizontalCenter
+                            anchors.top: parent.top
+                            anchors.topMargin: Math.round(panelImage.height / 4)
+                            color: Qt.lighter(screenRect.color)
+                            border.color: Kirigami.Theme.highlightColor
+                            width: Math.round(panelImage.width * 2)
+                            height: panelImage.height
+                            radius: Math.round(height / 2)
+                            rotation: 45
+                        }
+                    }
+
+                    Rectangle {
+                        id: panelBorder
+                        anchors.fill: parent
+                        color: "transparent"
+                        border.color: Kirigami.Theme.highlightColor
+                        radius: panelImage.radius
+                    }
+                }
+            }
+
+            Rectangle {
+                id: window
+                width: Math.round(parent.width / 2)
+                height: Math.round(parent.height / 2)
+                visible: root.windowVisible
+                radius: 5
+                color: Kirigami.Theme.highlightColor
+                border.color: "transparent"
+
+                x: root.isVertical ? Math.round(panelImage.x + panelImage.width / 2) : Math.round(screenRect.width / 2 - width / 2) + Kirigami.Units.gridUnit
+                y: root.isVertical ? Math.round(screenRect.height / 2 - height / 2) : Math.round(panelImage.y - height + panelImage.height / 2)
+                z: root.windowZ
+
+                Row {
+                    anchors.top: parent.top
+                    anchors.right: parent.right
+                    anchors.margins: Kirigami.Units.smallSpacing
+                    spacing: Kirigami.Units.smallSpacing
+                    Repeater {
+                        model: 3
+                        delegate: Rectangle {
+                            width: Math.round(Kirigami.Units.gridUnit / 6)
+                            height: width
+                            radius: Math.round(height / 2)
+                            color: Kirigami.Theme.textColor
+                        }
+                    }
+                }
+            }
+
+            Kirigami.Icon {
+                id: mainIcon
+                visible: valid
+                anchors.centerIn: parent
+                transform: Translate {
+                    y: root.isVertical ? 0 : Math.round((mainIcon.y - panelImage.y) / 4)
+                    x: root.isVertical ? Math.round((mainIcon.x - panelImage.x) / 4) : 0
+                }
+                height: parent.height / 2
+                source: root.mainIconSource
+            }
+        }
+    }
+}

plasma/shells/org.kde.plasma.desktop/configuration_old/panelconfiguration/Ruler.qml

@@ -0,0 +1,241 @@
+/*
+    SPDX-FileCopyrightText: 2013 Marco Martin <mart@kde.org>
+
+    SPDX-License-Identifier: GPL-2.0-or-later
+*/
+
+import QtQuick 2.0
+import QtQuick.Layouts 1.0
+import QtQuick.Controls 2.4 as QQC2
+import org.kde.plasma.plasmoid 2.0
+import org.kde.plasma.core as PlasmaCore
+import org.kde.plasma.extras 2.0 as PlasmaExtras
+import org.kde.kirigami 2.20 as Kirigami
+import org.kde.ksvg 1.0 as KSvg
+import org.kde.plasma.components 3.0 as PC3
+import org.kde.plasma.shell.panel 0.1 as Panel
+import org.kde.kquickcontrols 2.0
+
+KSvg.FrameSvgItem {
+    id: root
+
+    anchors.fill: parent
+
+    //Those properties get updated by PanelConfiguration.qml whenever a value in the panel changes
+    property alias offset: offsetHandle.value
+    property alias minimumLength: rightMinimumLengthHandle.value
+    property alias maximumLength: rightMaximumLengthHandle.value
+    property bool isHorizontal: root.prefix[0] === 'north' || root.prefix[0] === 'south'
+
+    property string maximumText: (dialogRoot.vertical ? i18nd("plasma_shell_org.kde.plasma.desktop", "Drag to change maximum height.") : i18nd("plasma_shell_org.kde.plasma.desktop", "Drag to change maximum width.")) + "\n" + i18nd("plasma_shell_org.kde.plasma.desktop", "Double click to reset.")
+    property string minimumText: (dialogRoot.vertical ? i18nd("plasma_shell_org.kde.plasma.desktop", "Drag to change minimum height.") : i18nd("plasma_shell_org.kde.plasma.desktop", "Drag to change minimum width.")) + "\n" + i18nd("plasma_shell_org.kde.plasma.desktop", "Double click to reset.")
+
+    imagePath: "widgets/containment-controls"
+    implicitWidth: Math.max(offsetHandle.width, rightMinimumLengthHandle.width + rightMaximumLengthHandle.width)
+    implicitHeight: Math.max(offsetHandle.height, rightMinimumLengthHandle.height + rightMaximumLengthHandle.height)
+
+    onMinimumLengthChanged: rightMinimumLengthHandle.value = leftMinimumLengthHandle.value = minimumLength
+    onMaximumLengthChanged: rightMaximumLengthHandle.value = leftMaximumLengthHandle.value = maximumLength
+
+    /* As offset and length have a different meaning in all alignments, the panel shifts on alignment change.
+     * This could result in wrong panel positions (e.g. panel shifted over monitor border).
+     * The fancy version would be a recalculation of all values, so that the panel stays at it's current position,
+     * but this would be error prone and complicated. As the panel alignment is rarely changed, it's not worth it.
+     * The more easy approach is just setting the panel offset to zero. This makes sure the panel has a valid position and size.
+     */
+    Connections {
+        target: panel
+        function onAlignmentChanged() {
+            offset = 0
+        }
+    }
+
+    Component.onCompleted: {
+        offsetHandle.value = panel.offset
+        rightMinimumLengthHandle.value = panel.minimumLength
+        rightMaximumLengthHandle.value = panel.maximumLength
+        leftMinimumLengthHandle.value = panel.minimumLength
+        leftMaximumLengthHandle.value = panel.maximumLength
+    }
+
+    KSvg.SvgItem {
+        id: centerMark
+        imagePath: "widgets/containment-controls"
+        elementId: dialogRoot.vertical ? "vertical-centerindicator" : "horizontal-centerindicator"
+        visible: panel.alignment === Qt.AlignCenter
+        width: dialogRoot.vertical ? parent.width : naturalSize.width
+        height: dialogRoot.vertical ? naturalSize.height : parent.height
+        anchors.centerIn: parent
+    }
+
+    SliderHandle {
+        id: offsetHandle
+        anchors {
+            right: !root.isHorizontal ? root.right : undefined
+            bottom: root.isHorizontal ? root.bottom : undefined
+        }
+        graphicElementName: "offsetslider"
+        description: i18nd("plasma_shell_org.kde.plasma.desktop", "Drag to change position on this screen edge.\nDouble click to reset.")
+        offset: panel.alignment === Qt.AlignCenter ? 0 : (dialogRoot.vertical ? panel.height : panel.width) / 2
+        property int position: (dialogRoot.vertical) ? y + height / 2 : x + width / 2
+        onPositionChanged: {
+            if (!offsetHandle.hasEverBeenMoved) return;
+            let panelLength = dialogRoot.vertical ? panel.height : panel.width
+            let rootLength = dialogRoot.vertical ? root.height : root.width
+            // Snap at the center
+            if (Math.abs(position - rootLength / 2) < 5) {
+                if (panel.alignment !== Qt.AlignCenter) {
+                    panel.alignment = Qt.AlignCenter
+                    // Coordinate change: since we switch from measuring the min/max
+                    // length from the side of the panel to the center of the panel,
+                    // we need to double the distance between the min/max indicators
+                    // and the panel side.
+                    panel.minimumLength += panel.minimumLength - panelLength
+                    panel.maximumLength += panel.maximumLength - panelLength
+                }
+                panel.offset = 0
+            } else if (position > rootLength / 2) {
+                if (panel.alignment === Qt.AlignCenter) {
+                    // This is the opposite of the previous comment, as we are
+                    // cutting in half the distance between the min/max indicators
+                    // and the side of the panel.
+                    panel.minimumLength -= (panel.minimumLength - panelLength) / 2
+                    panel.maximumLength -= (panel.maximumLength - panelLength) / 2
+                }
+                panel.alignment = Qt.AlignRight
+                panel.offset = Math.round(rootLength - position - offset)
+            } else if (position <= rootLength / 2) {
+                if (panel.alignment === Qt.AlignCenter) {
+                    panel.minimumLength -= (panel.minimumLength - panelLength) / 2
+                    panel.maximumLength -= (panel.maximumLength - panelLength) / 2
+                }
+                panel.alignment = Qt.AlignLeft
+                panel.offset = Math.round(position - offset)
+            }
+        }
+        /* The maximum/minimumPosition values are needed to prevent the user from moving a panel with
+         * center alignment to the left and then drag the position handle to the left.
+         * This would make the panel to go off the monitor:
+         * |<-        V        ->                         |
+         * |  ->      |      <-                           |
+         *            ^move this slider to the left
+         */
+        minimumPosition: {
+            var size = dialogRoot.vertical ? height : width
+            switch(panel.alignment){
+            case Qt.AlignLeft:
+                return -size / 2 + offset
+            case Qt.AlignRight:
+                return leftMaximumLengthHandle.value - size / 2 - offset
+            default:
+                return panel.maximumLength / 2 - size / 2
+            }
+        }
+        //Needed for the same reason as above
+        maximumPosition: {
+            var size = dialogRoot.vertical ? height : width
+            var rootSize = dialogRoot.vertical ? root.height : root.width
+            switch(panel.alignment){
+            case Qt.AlignLeft:
+                return rootSize - rightMaximumLengthHandle.value - size / 2 + offset
+            case Qt.AlignRight:
+                return rootSize - size / 2 - offset
+            default:
+                return rootSize - panel.maximumLength / 2 - size / 2
+            }
+        }
+        function defaultPosition(): int /*override*/ {
+            return 0;
+        }
+    }
+
+    /* The maximumPosition value for the right handles and the minimumPosition value for the left handles are
+     * needed to prevent the user from moving a panel with center alignment to the left (right) and then pull one of the
+     * right (left) sliders to the right (left).
+     * Because the left and right sliders are coupled, this would make the left (right) sliders to go off the monitor.
+     *
+     * |<-        V        ->                         |
+     * |   ->     |     <-                            |
+     *                      ^move this slider to the right
+     *
+     * The other max/min Position values just set a minimum panel size
+     */
+
+    SliderHandle {
+        id: rightMinimumLengthHandle
+        anchors {
+            left: !root.isHorizontal ? root.left : undefined
+            top: root.isHorizontal ? root.top : undefined
+        }
+        description: root.minimumText
+        alignment: panel.alignment | Qt.AlignLeft
+        visible: panel.alignment !== Qt.AlignRight
+        offset: panel.offset
+        graphicElementName: "minslider"
+        onValueChanged: panel.minimumLength = value
+        minimumPosition: offsetHandle.position + Kirigami.Units.gridUnit * 3
+        maximumPosition: {
+            var rootSize = dialogRoot.vertical ? root.height : root.width
+            var size = dialogRoot.vertical ? height : width
+            panel.alignment === Qt.AlignCenter ? Math.min(rootSize - size/2, rootSize + offset * 2 - size/2) : rootSize - size/2
+        }
+    }
+
+    SliderHandle {
+        id: rightMaximumLengthHandle
+        anchors {
+            right: !root.isHorizontal ? root.right : undefined
+            bottom: root.isHorizontal ? root.bottom : undefined
+        }
+        description: root.maximumText
+        alignment: panel.alignment | Qt.AlignLeft
+        visible: panel.alignment !== Qt.AlignRight
+        offset: panel.offset
+        graphicElementName: "maxslider"
+        onValueChanged: panel.maximumLength = value
+        minimumPosition: offsetHandle.position + Kirigami.Units.gridUnit * 3
+        maximumPosition: {
+            var rootSize = dialogRoot.vertical ? root.height : root.width
+            var size = dialogRoot.vertical ? height : width
+            panel.alignment === Qt.AlignCenter ? Math.min(rootSize - size/2, rootSize + offset * 2 - size/2) : rootSize - size/2
+        }
+    }
+
+    SliderHandle {
+        id: leftMinimumLengthHandle
+        anchors {
+            left: !root.isHorizontal ? root.left : undefined
+            top: root.isHorizontal ? root.top : undefined
+        }
+        description: root.minimumText
+        alignment: panel.alignment | Qt.AlignRight
+        visible: panel.alignment !== Qt.AlignLeft
+        offset: panel.offset
+        graphicElementName: "maxslider"
+        onValueChanged: panel.minimumLength = value
+        maximumPosition: offsetHandle.position - Kirigami.Units.gridUnit * 3
+        minimumPosition: {
+            var size = dialogRoot.vertical ? height : width
+            panel.alignment === Qt.AlignCenter ? Math.max(-size/2, offset*2 - size/2) : -size/2
+        }
+    }
+
+    SliderHandle {
+        id: leftMaximumLengthHandle
+        anchors {
+            right: !root.isHorizontal ? root.right : undefined
+            bottom: root.isHorizontal ? root.bottom : undefined
+        }
+        description: root.maximumText
+        alignment: panel.alignment | Qt.AlignRight
+        visible: panel.alignment !== Qt.AlignLeft
+        offset: panel.offset
+        graphicElementName: "minslider"
+        onValueChanged: panel.maximumLength = value
+        maximumPosition: offsetHandle.position - Kirigami.Units.gridUnit * 3
+        minimumPosition: {
+            var size = dialogRoot.vertical ? height : width
+            panel.alignment === Qt.AlignCenter ? Math.max(-size/2, offset*2 - size/2) : -size/2
+        }
+    }
+}

plasma/shells/org.kde.plasma.desktop/configuration_old/panelconfiguration/SliderHandle.qml

@@ -0,0 +1,237 @@
+/*
+    SPDX-FileCopyrightText: 2013 Marco Martin <mart@kde.org>
+
+    SPDX-License-Identifier: GPL-2.0-or-later
+*/
+
+import QtQuick 2.15
+import QtQuick.Layouts 1.0
+import QtQuick.Controls 2.4 as QQC2
+import org.kde.plasma.plasmoid 2.0
+import org.kde.plasma.core as PlasmaCore
+import org.kde.plasma.extras 2.0 as PlasmaExtras
+import org.kde.kirigami 2.20 as Kirigami
+import org.kde.ksvg 1.0 as KSvg
+import org.kde.plasma.components 3.0 as PC3
+import org.kde.plasma.shell.panel 0.1 as Panel
+import org.kde.kquickcontrols 2.0
+
+KSvg.SvgItem {
+    id: root
+
+    //Those properties get updated by PanelConfiguration.qml whenever a value changes
+    imagePath: "widgets/containment-controls"
+    elementId: parent.prefix + '-' + graphicElementName
+    width: naturalSize.width
+    height: naturalSize.height
+
+    //value expressed by this slider, this is the distance to offset
+    property int value
+
+    //name of the graphics to load
+    property string graphicElementName
+
+    //where the point "0" is
+    property int offset: 0
+
+    /*handle type: behave in different ways based on the alignment:
+     * alignment === Qt.AlignRight: Panel aligned to right and handle value relative to the right
+     * alignment === Qt.AlignLeft: Panel aligned to left and handle relative to the left
+     * (alignment !== Qt.AlignRight) && (alignment & Qt.AlignRight): Panel aligned to the center and handle right of offset and value doubled
+     * (alignment !== Qt.AlignLeft) && (alignment & Qt.AlignLeft): Panel aligned to the center and handle left of offset and value doubled
+     * else: Panel aligned to center and handle relative to the center
+     * Note that right/left and top/bottom are interchangeable
+     */
+    property int alignment: panel.alignment
+
+    //The maximum/minimum Position (X/Y) the silder can be moved to
+    property int minimumPosition
+    property int maximumPosition
+    //Provide default position for "reset" action.
+    function defaultPosition(): int {
+        var dialogSize, panelSize;
+        if (dialogRoot.vertical) {
+            dialogSize = dialogRoot.height;
+            panelSize = panel.height;
+        } else {
+            dialogSize = dialogRoot.width;
+            panelSize = panel.width;
+        }
+        return (value === panelSize) ? dialogSize : panelSize;
+    }
+
+    // Handle name displayed as a tooltip.
+    property string description
+
+    property bool hasEverBeenMoved: false
+
+    function syncPos() {
+        if (dialogRoot.vertical) {
+            if (alignment === Qt.AlignRight) {
+                y = root.parent.height - (value + offset + root.height/2)
+            } else if (alignment === Qt.AlignLeft) {
+                y = value + offset - root.height/2
+            } else {
+                if (root.alignment & Qt.AlignRight) {
+                    y = root.parent.height/2 - value/2 + offset - root.height/2
+                } else if (root.alignment & Qt.AlignLeft) {
+                    y = root.parent.height/2 + value/2 + offset - root.height/2
+                } else {
+                    y = root.parent.height/2 + value + offset -root.height/2
+                }
+            }
+        } else {
+            if (alignment === Qt.AlignRight) {
+                x = root.parent.width - (value + offset + root.width/2)
+            } else if (alignment === Qt.AlignLeft) {
+                x = value + offset - root.width/2
+            } else {
+                if (root.alignment & Qt.AlignRight) {
+                    x = root.parent.width/2 - value/2 + offset - root.width/2
+                } else if (root.alignment & Qt.AlignLeft) {
+                    x = root.parent.width/2 + value/2 + offset -root.width/2
+                } else {
+                    x = root.parent.width/2 + value + offset -root.width/2
+                }
+            }
+        }
+    }
+    onValueChanged: syncPos()
+    onOffsetChanged: syncPos()
+    onAlignmentChanged: syncPos()
+    Connections {
+        target: root.parent
+        function onWidthChanged() {
+            syncPos()
+        }
+        function onHeightChanged() {
+            syncPos()
+        }
+    }
+
+    PC3.ToolTip {
+        text: root.description
+        visible: root.description !== "" && ((area.containsMouse && !area.containsPress) || area.activeFocus)
+    }
+
+    MouseArea {
+        id: area
+        drag {
+            target: parent
+            axis: (dialogRoot.vertical) ? Drag.YAxis : Drag.XAxis
+            minimumX: root.minimumPosition
+            minimumY: root.minimumPosition
+            maximumX: root.maximumPosition
+            maximumY: root.maximumPosition
+        }
+        anchors {
+            fill: parent
+            leftMargin: (dialogRoot.vertical) ? 0 : -Kirigami.Units.gridUnit
+            rightMargin: (dialogRoot.vertical) ? 0 : -Kirigami.Units.gridUnit
+            topMargin: (dialogRoot.vertical) ? -Kirigami.Units.gridUnit : 0
+            bottomMargin: (dialogRoot.vertical) ? -Kirigami.Units.gridUnit : 0
+        }
+
+        readonly property int keyboardMoveStepSize: Math.ceil((root.maximumPosition - root.minimumPosition) / 20)
+
+        activeFocusOnTab: true
+        hoverEnabled: true
+        cursorShape: dialogRoot.vertical ? Qt.SizeVerCursor : Qt.SizeHorCursor
+
+        Accessible.description: root.description
+
+        Keys.onEnterPressed: doubleClicked(null);
+        Keys.onReturnPressed: doubleClicked(null);
+        Keys.onSpacePressed: doubleClicked(null);
+
+        // BEGIN Arrow keys
+        Keys.onUpPressed: if (dialogRoot.vertical) {
+            root.y = Math.max(root.minimumPosition, root.y - ((event.modifiers & Qt.ShiftModifier) ? 1 : keyboardMoveStepSize));
+            changePosition();
+        } else {
+            event.accepted = false;
+        }
+        Keys.onDownPressed: if (dialogRoot.vertical) {
+            root.y = Math.min(root.maximumPosition, root.y + ((event.modifiers & Qt.ShiftModifier) ? 1 : keyboardMoveStepSize));
+            changePosition();
+        } else {
+            event.accepted = false;
+        }
+        Keys.onLeftPressed: if (!dialogRoot.vertical) {
+            root.x = Math.max(root.minimumPosition, root.x - ((event.modifiers & Qt.ShiftModifier) ? 1 : keyboardMoveStepSize));
+            changePosition();
+        } else {
+            event.accepted = false;
+        }
+        Keys.onRightPressed: if (!dialogRoot.vertical) {
+            root.x = Math.min(root.maximumPosition, root.x + ((event.modifiers & Qt.ShiftModifier) ? 1 : keyboardMoveStepSize));
+            changePosition();
+        } else {
+            event.accepted = false;
+        }
+        // END Arrow keys
+
+        onPositionChanged: {
+            if (!drag.active) {
+                return;
+            }
+            changePosition();
+        }
+        onDoubleClicked: {
+            root.value = root.defaultPosition();
+        }
+
+        function changePosition() {
+            root.hasEverBeenMoved = true
+            if (dialogRoot.vertical) {
+                if (root.alignment === Qt.AlignRight) {
+                    root.value = root.parent.height - (root.y + offset + root.height/2)
+                } else if (alignment === Qt.AlignLeft) {
+                    root.value = root.y - offset + root.height/2
+                //Center
+                } else {
+                    if (root.alignment & Qt.AlignRight) {
+                        root.value = (root.parent.height/2 - root.y + offset)*2  - root.height
+                    } else if (root.alignment & Qt.AlignLeft) {
+                        root.value = (root.y - offset - root.parent.height/2)*2  + root.height
+                    } else {
+                        var value = root.y - root.parent.height/2 - offset + root.height/2
+                        //Snap
+                        if (Math.abs(value) < 5) {
+                            root.value = 0
+                        } else {
+                            root.value = value
+                        }
+                    }
+                }
+            } else {
+                if (root.alignment === Qt.AlignRight) {
+                    root.value = root.parent.width - (root.x + offset + root.width/2)
+                } else if (alignment === Qt.AlignLeft) {
+                    root.value = root.x - offset + root.width/2
+                //Center
+                } else {
+                    if (root.alignment & Qt.AlignRight) {
+                        root.value = (root.parent.width/2 - root.x + offset)*2 - root.width
+                    } else if (root.alignment & Qt.AlignLeft) {
+                        root.value = (root.x - offset - root.parent.width/2)*2  + root.width
+                    } else {
+                        var value = root.x - root.parent.width/2 - offset + root.width/2
+                        //Snap
+                        if (Math.abs(value) < 5) {
+                            root.value = 0
+                        } else {
+                            root.value = value
+                        }
+                    }
+                }
+            }
+        }
+
+        PlasmaExtras.Highlight {
+            anchors.fill: parent
+            visible: parent.activeFocus
+            hovered: true
+        }
+    }
+}