diff --git a/applet/contents/ui/ListItemBase.qml b/applet/contents/ui/ListItemBase.qml
index afc7e02..db517c6 100644
--- a/applet/contents/ui/ListItemBase.qml
+++ b/applet/contents/ui/ListItemBase.qml
@@ -1,208 +1,208 @@
 /*
     Copyright 2014-2015 Harald Sitter <sitter@kde.org>
 
     This program is free software; you can redistribute it and/or
     modify it under the terms of the GNU General Public License as
     published by the Free Software Foundation; either version 2 of
     the License or (at your option) version 3 or any later version
     accepted by the membership of KDE e.V. (or its successor approved
     by the membership of KDE e.V.), which shall act as a proxy
     defined in Section 14 of version 3 of the license.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 import QtQuick 2.4
 import QtQuick.Controls 1.0
 import QtQuick.Layouts 1.0
 
 import org.kde.kquickcontrolsaddons 2.0
 import org.kde.plasma.components 2.0 as PlasmaComponents
 import org.kde.plasma.core 2.0 as PlasmaCore
 import org.kde.plasma.extras 2.0 as PlasmaExtras
 import org.kde.draganddrop 2.0 as DragAndDrop
 
 import org.kde.plasma.private.volume 0.1
 
 PlasmaComponents.ListItem {
     id: item
 
     property alias label: textLabel.text
     property alias draggable: dragArea.enabled
     property alias icon: clientIcon.source
     property string type
 
     anchors {
         left: parent.left;
         right: parent.right;
     }
 
     checked: dropArea.containsDrag
     opacity: (draggedStream && draggedStream.deviceIndex == Index) ? 0.3 : 1.0
 
     ListView.delayRemove: dragArea.dragActive
 
     DragAndDrop.DropArea {
         id: dropArea
         anchors.fill: parent
         enabled: draggedStream
 
         onDragEnter: {
             if (draggedStream.deviceIndex == Index) {
                 event.ignore();
             }
         }
 
         onDrop: {
             draggedStream.deviceIndex = Index;
         }
     }
 
     ColumnLayout {
         property int maximumWidth: parent.width
         width: maximumWidth
         Layout.maximumWidth: maximumWidth
 
         RowLayout {
             Layout.fillWidth: true
             spacing: units.smallSpacing
 
             PlasmaCore.IconItem {
                 id: clientIcon
                 visible: valid
                 Layout.alignment: Qt.AlignHCenter
                 Layout.preferredHeight: column.height * 0.75
                 Layout.preferredWidth: Layout.preferredHeight
 
                 DragAndDrop.DragArea {
                     id: dragArea
                     anchors.fill: parent
                     delegate: parent
 
                     mimeData {
                         source: item
                     }
 
                     onDragStarted: {
                         draggedStream = PulseObject;
                         main.beginMoveStream(type == "sink-input" ? "sink" : "source");
                     }
 
                     onDrop: {
                         draggedStream = null;
                         main.endMoveStream();
                     }
 
                     MouseArea {
                         anchors.fill: parent
                         cursorShape: dragArea.enabled ? (pressed ? Qt.ClosedHandCursor : Qt.OpenHandCursor) : undefined
                     }
                 }
             }
 
             ColumnLayout {
                 id: column
 
                 PlasmaExtras.Heading {
                     id :textLabel
                     Layout.fillWidth: true
                     level: 5
                     opacity: 0.6
                     wrapMode: Text.NoWrap
                     elide: Text.ElideRight
                 }
 
                 RowLayout {
                     VolumeIcon {
                         Layout.maximumHeight: slider.height * 0.75
                         Layout.maximumWidth: slider.height* 0.75
                         volume: Volume
                         muted: Muted
 
                         MouseArea {
                             anchors.fill: parent
                             onPressed: Muted = !Muted
                         }
                     }
 
                     PlasmaComponents.Slider {
                         id: slider
 
                         // Helper properties to allow async slider updates.
                         // While we are sliding we must not react to value updates
                         // as otherwise we can easily end up in a loop where value
                         // changes trigger volume changes trigger value changes.
                         property int volume: Volume
                         property bool ignoreValueChange: false
 
                         Layout.fillWidth: true
                         minimumValue: PulseAudio.MinimalVolume
                         maximumValue: maxVolumeValue
                         stepSize: maximumValue / maxVolumePercent
                         visible: HasVolume
                         enabled: VolumeWritable
                         opacity: Muted ? 0.5 : 1
 
                         onVolumeChanged: {
                             ignoreValueChange = true;
                             value = Volume;
                             ignoreValueChange = false;
                         }
 
                         onValueChanged: {
                             if (!ignoreValueChange) {
                                 Volume = value;
                                 Muted = false;
 
                                 if (type == "sink") {
-                                    playFeedback(CardIndex);
+                                    playFeedback(Index);
                                 }
 
                                 if (!pressed) {
                                     updateTimer.restart();
                                 }
                             }
                         }
 
                         onPressedChanged: {
                             if (!pressed) {
                                 // Make sure to sync the volume once the button was
                                 // released.
                                 // Otherwise it might be that the slider is at v10
                                 // whereas PA rejected the volume change and is
                                 // still at v15 (e.g.).
                                 updateTimer.restart();
                             }
                         }
 
                         Timer {
                             id: updateTimer
                             interval: 200
                             onTriggered: slider.value = Volume
                         }
                     }
                     PlasmaComponents.Label {
                         id: percentText
                         readonly property real value: PulseObject.volume > slider.maximumValue ? PulseObject.volume : slider.value
                         Layout.alignment: Qt.AlignHCenter
                         Layout.minimumWidth: percentMetrics.advanceWidth
                         horizontalAlignment: Qt.AlignRight
                         text: i18nc("volume percentage", "%1%", Math.round(value / PulseAudio.NormalVolume * 100.0))
                     }
 
                     TextMetrics {
                         id: percentMetrics
                         font: percentText.font
                         text: i18nc("only used for sizing, should be widest possible string", "100%")
                     }
                 }
             }
         }
     }
 }
diff --git a/applet/contents/ui/main.qml b/applet/contents/ui/main.qml
index a8cd62a..a2ae3a5 100644
--- a/applet/contents/ui/main.qml
+++ b/applet/contents/ui/main.qml
@@ -1,415 +1,415 @@
 /*
     Copyright 2014-2015 Harald Sitter <sitter@kde.org>
 
     This program is free software; you can redistribute it and/or
     modify it under the terms of the GNU General Public License as
     published by the Free Software Foundation; either version 2 of
     the License or (at your option) version 3 or any later version
     accepted by the membership of KDE e.V. (or its successor approved
     by the membership of KDE e.V.), which shall act as a proxy
     defined in Section 14 of version 3 of the license.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 import QtQuick 2.0
 import QtQuick.Layouts 1.0
 
 import org.kde.plasma.core 2.0 as PlasmaCore
 import org.kde.plasma.components 2.0 as PlasmaComponents
 import org.kde.plasma.extras 2.0 as PlasmaExtras
 import org.kde.plasma.plasmoid 2.0
 
 import org.kde.plasma.private.volume 0.1
 
 import "../code/icon.js" as Icon
 
 Item {
     id: main
 
     property bool volumeFeedback: Plasmoid.configuration.volumeFeedback
     property int maxVolumePercent: Plasmoid.configuration.maximumVolume
     property int maxVolumeValue: Math.round(maxVolumePercent * PulseAudio.NormalVolume / 100.0)
     property int volumeStep: Math.round(Plasmoid.configuration.volumeStep * PulseAudio.NormalVolume / 100.0)
     property string displayName: i18n("Audio Volume")
     property QtObject draggedStream: null
 
     Layout.minimumHeight: units.gridUnit * 12
     Layout.minimumWidth: units.gridUnit * 12
     Layout.preferredHeight: units.gridUnit * 20
     Layout.preferredWidth: units.gridUnit * 20
 
     Plasmoid.icon: sinkModel.preferredSink ? Icon.name(sinkModel.preferredSink.volume, sinkModel.preferredSink.muted) : Icon.name(0, true)
     Plasmoid.switchWidth: units.gridUnit * 12
     Plasmoid.switchHeight: units.gridUnit * 12
     Plasmoid.toolTipMainText: displayName
     Plasmoid.toolTipSubText: sinkModel.preferredSink ? i18n("Volume at %1%\n%2", volumePercent(sinkModel.preferredSink.volume), sinkModel.preferredSink.description) : ""
 
     function boundVolume(volume) {
         return Math.max(PulseAudio.MinimalVolume, Math.min(volume, maxVolumeValue));
     }
 
     function volumePercent(volume, max) {
         if (!max) {
             max = PulseAudio.NormalVolume;
         }
         return Math.round(volume / max * 100.0);
     }
 
     function increaseVolume() {
         if (!sinkModel.preferredSink) {
             return;
         }
         var volume = boundVolume(sinkModel.preferredSink.volume + volumeStep);
         var percent = volumePercent(volume, maxVolumeValue);
         sinkModel.preferredSink.muted = percent == 0;
         sinkModel.preferredSink.volume = volume;
         osd.show(percent);
         playFeedback();
     }
 
     function decreaseVolume() {
         if (!sinkModel.preferredSink) {
             return;
         }
         var volume = boundVolume(sinkModel.preferredSink.volume - volumeStep);
         var percent = volumePercent(volume, maxVolumeValue);
         sinkModel.preferredSink.muted = percent == 0;
         sinkModel.preferredSink.volume = volume;
         osd.show(percent);
         playFeedback();
     }
 
     function muteVolume() {
         if (!sinkModel.preferredSink) {
             return;
         }
         var toMute = !sinkModel.preferredSink.muted;
         sinkModel.preferredSink.muted = toMute;
         osd.show(toMute ? 0 : volumePercent(sinkModel.preferredSink.volume, maxVolumeValue));
         playFeedback();
     }
 
     function increaseMicrophoneVolume() {
         if (!sourceModel.defaultSource) {
             return;
         }
         var volume = boundVolume(sourceModel.defaultSource.volume + volumeStep);
         var percent = volumePercent(volume);
         sourceModel.defaultSource.muted = percent == 0;
         sourceModel.defaultSource.volume = volume;
         osd.showMicrophone(percent);
     }
 
     function decreaseMicrophoneVolume() {
         if (!sourceModel.defaultSource) {
             return;
         }
         var volume = boundVolume(sourceModel.defaultSource.volume - volumeStep);
         var percent = volumePercent(volume);
         sourceModel.defaultSource.muted = percent == 0;
         sourceModel.defaultSource.volume = volume;
         osd.showMicrophone(percent);
     }
 
     function muteMicrophone() {
         if (!sourceModel.defaultSource) {
             return;
         }
         var toMute = !sourceModel.defaultSource.muted;
         sourceModel.defaultSource.muted = toMute;
         osd.showMicrophone(toMute? 0 : volumePercent(sourceModel.defaultSource.volume));
     }
 
     function beginMoveStream(type, stream) {
         if (type == "sink") {
             sourceView.visible = false;
             sourceViewHeader.visible = false;
         } else if (type == "source") {
             sinkView.visible = false;
             sinkViewHeader.visible = false;
         }
 
         tabBar.currentTab = devicesTab;
     }
 
     function endMoveStream() {
         tabBar.currentTab = streamsTab;
 
         sourceView.visible = true;
         sourceViewHeader.visible = true;
         sinkView.visible = true;
         sinkViewHeader.visible = true;
     }
 
     function playFeedback(sinkIndex) {
         if (!volumeFeedback) {
             return;
         }
         if (!sinkIndex) {
-            sinkIndex = sinkModel.preferredSink.cardIndex;
+            sinkIndex = sinkModel.preferredSink.index;
         }
         feedback.play(sinkIndex);
     }
 
     Plasmoid.compactRepresentation: PlasmaCore.IconItem {
         source: plasmoid.icon
         active: mouseArea.containsMouse
         colorGroup: PlasmaCore.ColorScope.colorGroup
 
         MouseArea {
             id: mouseArea
 
             property int wheelDelta: 0
             property bool wasExpanded: false
 
             anchors.fill: parent
             hoverEnabled: true
             acceptedButtons: Qt.LeftButton | Qt.MiddleButton
             onPressed: {
                 if (mouse.button == Qt.LeftButton) {
                     wasExpanded = plasmoid.expanded;
                 } else if (mouse.button == Qt.MiddleButton) {
                     muteVolume();
                 }
             }
             onClicked: {
                 if (mouse.button == Qt.LeftButton) {
                     plasmoid.expanded = !wasExpanded;
                 }
             }
             onWheel: {
                 var delta = wheel.angleDelta.y || wheel.angleDelta.x;
                 wheelDelta += delta;
                 // Magic number 120 for common "one click"
                 // See: http://qt-project.org/doc/qt-5/qml-qtquick-wheelevent.html#angleDelta-prop
                 while (wheelDelta >= 120) {
                     wheelDelta -= 120;
                     increaseVolume();
                 }
                 while (wheelDelta <= -120) {
                     wheelDelta += 120;
                     decreaseVolume();
                 }
             }
         }
     }
 
     GlobalActionCollection {
         // KGlobalAccel cannot transition from kmix to something else, so if
         // the user had a custom shortcut set for kmix those would get lost.
         // To avoid this we hijack kmix name and actions. Entirely mental but
         // best we can do to not cause annoyance for the user.
         // The display name actually is updated to whatever registered last
         // though, so as far as user visible strings go we should be fine.
         // As of 2015-07-21:
         //   componentName: kmix
         //   actions: increase_volume, decrease_volume, mute
         name: "kmix"
         displayName: main.displayName
         GlobalAction {
             objectName: "increase_volume"
             text: i18n("Increase Volume")
             shortcut: Qt.Key_VolumeUp
             onTriggered: increaseVolume()
         }
         GlobalAction {
             objectName: "decrease_volume"
             text: i18n("Decrease Volume")
             shortcut: Qt.Key_VolumeDown
             onTriggered: decreaseVolume()
         }
         GlobalAction {
             objectName: "mute"
             text: i18n("Mute")
             shortcut: Qt.Key_VolumeMute
             onTriggered: muteVolume()
         }
         GlobalAction {
             objectName: "increase_microphone_volume"
             text: i18n("Increase Microphone Volume")
             shortcut: Qt.Key_MicVolumeUp
             onTriggered: increaseMicrophoneVolume()
         }
         GlobalAction {
             objectName: "decrease_microphone_volume"
             text: i18n("Decrease Microphone Volume")
             shortcut: Qt.Key_MicVolumeDown
             onTriggered: decreaseMicrophoneVolume()
         }
         GlobalAction {
             objectName: "mic_mute"
             text: i18n("Mute Microphone")
             shortcut: Qt.Key_MicMute
             onTriggered: muteMicrophone()
         }
     }
 
     VolumeOSD {
         id: osd
     }
 
     VolumeFeedback {
         id: feedback
     }
 
     PlasmaComponents.TabBar {
         id: tabBar
 
         anchors {
             top: parent.top
             left: parent.left
             right: parent.right
         }
 
         PlasmaComponents.TabButton {
             id: devicesTab
             text: i18n("Devices")
         }
 
         PlasmaComponents.TabButton {
             id: streamsTab
             text: i18n("Applications")
         }
     }
 
     PlasmaExtras.ScrollArea {
         id: scrollView;
 
         anchors {
             top: tabBar.bottom
             topMargin: units.smallSpacing
             left: parent.left
             right: parent.right
             bottom: parent.bottom
         }
 
         horizontalScrollBarPolicy: Qt.ScrollBarAlwaysOff
         flickableItem.boundsBehavior: Flickable.StopAtBounds;
 
         Item {
             width: streamsView.visible ? streamsView.width : devicesView.width
             height: streamsView.visible ? streamsView.height : devicesView.height
 
             ColumnLayout {
                 id: streamsView
                 visible: tabBar.currentTab == streamsTab
                 property int maximumWidth: scrollView.viewport.width
                 width: maximumWidth
                 Layout.maximumWidth: maximumWidth
 
                 Header {
                     Layout.fillWidth: true
                     visible: sinkInputView.count > 0
                     text: i18n("Playback Streams")
                 }
                 ListView {
                     id: sinkInputView
 
                     Layout.fillWidth: true
                     Layout.minimumHeight: contentHeight
                     Layout.maximumHeight: contentHeight
 
                     model: PulseObjectFilterModel {
                         filters: [ { role: "VirtualStream", value: false } ]
                         sourceModel: SinkInputModel {}
                     }
                     boundsBehavior: Flickable.StopAtBounds;
                     delegate: StreamListItem {
                         type: "sink-input"
                         draggable: sinkView.count > 1
                     }
                 }
 
                 Header {
                     Layout.fillWidth: true
                     visible: sourceOutputView.count > 0
                     text: i18n("Capture Streams")
                 }
                 ListView {
                     id: sourceOutputView
 
                     Layout.fillWidth: true
                     Layout.minimumHeight: contentHeight
                     Layout.maximumHeight: contentHeight
 
                     model: PulseObjectFilterModel {
                         filters: [ { role: "VirtualStream", value: false } ]
                         sourceModel: SourceOutputModel {}
                     }
                     boundsBehavior: Flickable.StopAtBounds;
                     delegate: StreamListItem {
                         type: "source-input"
                         draggable: sourceView.count > 1
                     }
                 }
             }
 
             ColumnLayout {
                 id: devicesView
                 visible: tabBar.currentTab == devicesTab
                 property int maximumWidth: scrollView.viewport.width
                 width: maximumWidth
                 Layout.maximumWidth: maximumWidth
 
                 Header {
                     id: sinkViewHeader
                     Layout.fillWidth: true
                     visible: sinkView.count > 0
                     text: i18n("Playback Devices")
                 }
                 ListView {
                     id: sinkView
 
                     Layout.fillWidth: true
                     Layout.minimumHeight: contentHeight
                     Layout.maximumHeight: contentHeight
 
                     model: PulseObjectFilterModel {
                         sortRole: "SortByDefault"
                         sortOrder: Qt.DescendingOrder
                         sourceModel: SinkModel {
                             id: sinkModel
                         }
                     }
                     boundsBehavior: Flickable.StopAtBounds;
                     delegate: DeviceListItem {
                         type: "sink"
                     }
                 }
 
                 Header {
                     id: sourceViewHeader
                     Layout.fillWidth: true
                     visible: sourceView.count > 0
                     text: i18n("Capture Devices")
                 }
                 ListView {
                     id: sourceView
 
                     Layout.fillWidth: true
                     Layout.minimumHeight: contentHeight
                     Layout.maximumHeight: contentHeight
 
                     model: PulseObjectFilterModel {
                         sortRole: "SortByDefault"
                         sortOrder: Qt.DescendingOrder
                         sourceModel: SourceModel {
                             id: sourceModel
                         }
                     }
                     boundsBehavior: Flickable.StopAtBounds;
                     delegate: DeviceListItem {
                         type: "source"
                     }
                 }
             }
         }
     }
 }