diff --git a/applets/comic/package/contents/ui/main.qml b/applets/comic/package/contents/ui/main.qml
index 63438e058..7034158a3 100644
--- a/applets/comic/package/contents/ui/main.qml
+++ b/applets/comic/package/contents/ui/main.qml
@@ -1,231 +1,231 @@
 /*
  * Copyright 2012  Reza Fatahilah Shah <rshah0385@kireihana.com>
  *
  * 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) any later version.
  *
  * 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.1
 import QtQuick.Layouts 1.1
 
 import org.kde.plasma.plasmoid 2.0
 import org.kde.plasma.core 2.0 as PlasmaCore
 import org.kde.plasma.components 2.0 as PlasmaComponents
 import org.kde.kquickcontrolsaddons 2.0
 
 Item {
     id: mainWindow
 
     property int implicitWidth: units.gridUnit * 40
     property int implicitHeight: units.gridUnit * 15
     Plasmoid.switchWidth: {
         if (centerLayout.comicData.image) {
             return Math.max(minimumWidth, Math.min(centerLayout.comicData.image.nativeWidth * 0.6, implicitWidth));
         } else {
             return units.gridUnit * 8;
         }
     }
     Plasmoid.switchHeight: {
         if (centerLayout.comicData.image) {
             return Math.max(minimumHeight, Math.min(centerLayout.comicData.image.nativeHeight * 0.6, implicitHeight));
         } else {
             return units.gridUnit * 8;
         }
     }
     Plasmoid.icon: "face-laughing"
 
     width: implicitWidth
     height: implicitHeight
 
     property int minimumWidth: units.gridUnit * 8
     property int minimumHeight: units.gridUnit * 8
     property bool showComicAuthor: plasmoid.nativeInterface.showComicAuthor
     property bool showComicTitle: plasmoid.nativeInterface.showComicTitle
     property bool showErrorPicture: plasmoid.nativeInterface.showErrorPicture
     property bool middleClick: plasmoid.nativeInterface.middleClick
 
     Connections {
         target: plasmoid.nativeInterface
 
         onComicsModelChanged: {
             comicTabbar.currentTab = comicTabbar.layout.children[1];
         }
 
         onTabHighlightRequest: {
             for (var i = 0; i < comicTabbar.layout.children.length; ++i) {
                 var button = comicTabbar.layout.children[i];
 
                 if (button.key !== undefined && button.key == id) {
                     button.highlighted = highlight;
                 }
             }
         }
 
         onShowNextNewStrip: {
             var firstButton = undefined;
 
             for (var i = 0; i < comicTabbar.layout.children.length; ++i) {
                 var button = comicTabbar.layout.children[i];
                 if (button.key !== undefined && button.highlighted == true) {
                     //key is ordered
                     if (button.key > comicTabbar.currentTab.key) {
                         comicTabbar.currentTab = button;
                         return;
                     } else if (firstButton === undefined){
                         firstButton = button;
                     }
                 }
             }
 
             if (firstButton !== undefined) {
                 comicTabbar.currentTab = firstButton;
             }
         }
     }
 
     PlasmaCore.Svg {
         id: arrowsSvg
         imagePath: "widgets/arrows"
     }
 
     PlasmaComponents.TabBar{
         id: comicTabbar
 
         anchors {
             left: parent.left
             right: parent.right
         }
 
         visible: plasmoid.nativeInterface.tabIdentifiers.length > 1
 
         onCurrentTabChanged: {
             console.log("onCurrentTabChanged:" + comicTabbar.currentTab.key);
             plasmoid.nativeInterface.tabChanged(comicTabbar.currentTab.key);
         }
 
         Repeater {
             model: plasmoid.nativeInterface.comicsModel
             delegate:  PlasmaComponents.TabButton {
                 id: tabButton
 
                 property string key: model.key
                 property bool highlighted: model.highlight
 
                 text: model.title
                 iconSource: model.icon
             }
         }
     }
 
     PlasmaComponents.Label {
         id: topInfo
 
         anchors {
             top: comicTabbar.visible ? comicTabbar.bottom : mainWindow.top
             left: mainWindow.left
             right: mainWindow.right
         }
 
         visible: (topInfo.text.length > 0)
         horizontalAlignment: Text.AlignHCenter
         text: (showComicAuthor || showComicTitle) ? getTopInfo() : ""
 
         function getTopInfo() {
             var tempTop = "";
 
             if ( showComicTitle ) {
                 tempTop = plasmoid.nativeInterface.comicData.title;
                 tempTop += ( ( (plasmoid.nativeInterface.comicData.stripTitle.length > 0) && (plasmoid.nativeInterface.comicData.title.length > 0) ) ? " - " : "" ) + plasmoid.nativeInterface.comicData.stripTitle;
             }
 
             if ( showComicAuthor &&
                 (plasmoid.nativeInterface.comicData.author != undefined || plasmoid.nativeInterface.comicData.author.length > 0) ) {
                 tempTop = ( tempTop.length > 0 ? plasmoid.nativeInterface.comicData.author + ": " + tempTop : plasmoid.nativeInterface.comicData.author );
             }
 
             return tempTop;
         }
     }
 
     ComicCentralView {
         id: centerLayout
 
         anchors {
             left: mainWindow.left
             right: mainWindow.right
             bottom: (bottomInfo.visible) ? bottomInfo.top : mainWindow.bottom
             top: (topInfo.visible) ? topInfo.bottom : (comicTabbar.visible ? comicTabbar.bottom : mainWindow.top)
             topMargin: (comicTabbar.visible) ? 3 : 0
         }
 
         visible: plasmoid.nativeInterface.tabIdentifiers.length > 0
         comicData: plasmoid.nativeInterface.comicData
     }
 
     ComicBottomInfo {
         id:bottomInfo
 
         anchors {
             left: mainWindow.left
             right: mainWindow.right
             bottom: mainWindow.bottom
         }
 
         comicData: plasmoid.nativeInterface.comicData
         showUrl: plasmoid.nativeInterface.showComicUrl
         showIdentifier: plasmoid.nativeInterface.showComicIdentifier
     }
 
     PlasmaComponents.Button {
         anchors.centerIn: parent
-        text: i18n("Configure...")
+        text: i18nc("@action:button", "Configure...")
         visible: plasmoid.nativeInterface.tabIdentifiers.length == 0
         onClicked: plasmoid.action("configure").trigger();
     }
 
     states: [
         State {
             name: "topInfoVisible"
             when: topInfo.visible && !bottomInfo.visible
             AnchorChanges {
                 target: centerLayout
                 anchors.top: topInfo.bottom
             }
         },
         State {
             name: "bottomInfoVisible"
             when: bottomInfo.visible && !topInfo.visible
             AnchorChanges {
                 target: centerLayout
                 anchors.bottom: bottomInfo.top
             }
         },
         State {
             name: "topBottomInfoVisible"
             when: bottomInfo.visible && topInfo.visible
             AnchorChanges {
                 target: centerLayout
                 anchors.top: topInfo.bottom
                 anchors.bottom: bottomInfo.top
             }
         }
     ]
 
     transitions:
         Transition {
             AnchorAnimation {
                 duration: 500
                 easing.type: Easing.InOutQuad
             }
         }
 }
diff --git a/applets/mediaframe/package/contents/ui/main.qml b/applets/mediaframe/package/contents/ui/main.qml
index bd8b1703a..d0969d350 100644
--- a/applets/mediaframe/package/contents/ui/main.qml
+++ b/applets/mediaframe/package/contents/ui/main.qml
@@ -1,445 +1,445 @@
 /*
  *  Copyright 2015  Lars Pontoppidan <dev.larpon@gmail.com>
  *
  *  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) any later version.
  *
  *  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, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  2.010-1301, USA.
  */
 
 import QtQuick 2.5
 import QtQuick.Layouts 1.1
 import QtQuick.Dialogs 1.2
 import QtQuick.Controls 1.3
 import QtQuick.Controls.Styles 1.2
 
 import org.kde.draganddrop 2.0 as DragDrop
 
 import org.kde.plasma.plasmoid 2.0
 import org.kde.plasma.core 2.0 as PlasmaCore
 import org.kde.plasma.components 2.0 as PlasmaComponents
 import org.kde.kquickcontrolsaddons 2.0
 
 import org.kde.plasma.private.mediaframe 2.0
 
 Item {
     id: main
 
     MediaFrame {
         id: items
         random: plasmoid.configuration.randomize
     }
 
     Plasmoid.preferredRepresentation: plasmoid.fullRepresentation
 
     Plasmoid.switchWidth: units.gridUnit * 5
     Plasmoid.switchHeight: units.gridUnit * 5
 
     Plasmoid.backgroundHints: plasmoid.configuration.useBackground ? PlasmaCore.Types.DefaultBackground : PlasmaCore.Types.NoBackground
 
     width: units.gridUnit * 20
     height: units.gridUnit * 13
 
     property string activeSource: ""
     property string transitionSource: ""
 
     property bool pause: overlayMouseArea.containsMouse
 
     readonly property int itemCount: (items.count + items.futureLength())
     readonly property bool hasItems: ((itemCount > 0) || (items.futureLength() > 0))
     readonly property bool isTransitioning: faderAnimation.running
 
     onActiveSourceChanged: {
         items.watch(activeSource)
     }
 
     onHasItemsChanged: {
         if(hasItems) {
             if(activeSource == "")
                 nextItem()
         }
     }
 
     function loadPathList() {
         var list = plasmoid.configuration.pathList
         items.clear()
         for(var i in list) {
             var item = JSON.parse(list[i])
             items.add(item.path,true)
         }
     }
 
     Component.onCompleted: {
         loadPathList()
 
         if (items.random)
             nextItem()
     }
 
     Connections {
         target: plasmoid.configuration
         onPathListChanged: loadPathList()
     }
 
     function addItem(item) {
 
         if(items.isAdded(item.path)) {
             console.info(item.path,"already exists. Skipping...")
             return
         }
         // work-around for QTBUG-67773:
         // C++ object property of type QVariant(QStringList) is not updated on changes from QML
         // so explicitly create a deep JSValue copy, modify that and then set it back to overwrite the old
         var updatedList = plasmoid.configuration.pathList.slice();
         updatedList.push(JSON.stringify(item));
         plasmoid.configuration.pathList = updatedList;
     }
 
     function nextItem() {
 
         if(!hasItems) {
             console.warn("No items available")
             return
         }
 
         var active = activeSource
 
         // Only record history if we have more than one item
         if(itemCount > 1)
             items.pushHistory(active)
 
         if(items.futureLength() > 0) {
             setActiveSource(items.popFuture())
         } else {
             //setLoading()
             items.get(function(filePath){
                 setActiveSource(filePath)
                 //unsetLoading()
             },function(errorMessage){
                 //unsetLoading()
                 console.error("Error while getting next image",errorMessage)
             })
         }
     }
 
     function previousItem() {
         var active = activeSource
         items.pushFuture(active)
         var filePath = items.popHistory()
         setActiveSource(filePath)
     }
 
     Connections {
         target: items
 
         onItemChanged: {
             console.log("item",path,"changed")
             activeSource = ""
             setActiveSource(path)
         }
 
     }
 
     Timer {
         id: nextTimer
         interval: (plasmoid.configuration.interval*1000)
         repeat: true
         running: hasItems && !pause
         onTriggered: nextItem()
     }
 
     Item {
         id: itemView
         anchors.fill: parent
 
         /*
         Video {
             id: video
             width : 800
             height : 600
             source: ""
 
             onStatusChanged: {
                 if(status == Video.Loaded)
                     video.play()
             }
         }
         */
 
         Item {
             id: imageView
             visible: hasItems
             anchors.fill: parent
 
             Image {
                 id: bufferImage
 
 
                 anchors.fill: parent
                 fillMode: plasmoid.configuration.fillMode
 
                 opacity: 0
 
                 cache: false
                 source: transitionSource
 
                 asynchronous: true
                 autoTransform: true
             }
 
             Image {
                 id: frontImage
 
                 anchors.fill: parent
                 fillMode: plasmoid.configuration.fillMode
 
                 cache: false
                 source: activeSource
 
                 asynchronous: true
                 autoTransform: true
 
                 MouseArea {
                     anchors.fill: parent
                     onClicked: Qt.openUrlExternally(activeSource)
                     enabled: plasmoid.configuration.leftClickOpenImage
                 }
 
             }
         }
 
         // BUG TODO fix the rendering of the drop shadow
         /*
         DropShadow {
             id: itemViewDropShadow
             anchors.fill: parent
             visible: imageView.visible && !plasmoid.configuration.useBackground
 
             radius: 8.0
             samples: 16
             color: "#80000000"
             source: frontImage
         }
         */
 
     }
 
     function setActiveSource(source) {
         if(itemCount > 1) { // Only do transition if we have more that one item
             transitionSource = source
             faderAnimation.restart()
         } else {
             transitionSource = source
             activeSource = source
         }
     }
 
     SequentialAnimation {
         id: faderAnimation
 
         ParallelAnimation {
             OpacityAnimator { target: frontImage; from: 1; to: 0; duration: 450 }
             OpacityAnimator { target: bufferImage; from: 0; to: 1; duration: 450 }
         }
         ScriptAction {
             script: {
                 // Copy the transitionSource
                 var ts = transitionSource
                 activeSource = ts
                 frontImage.opacity = 1
                 transitionSource = ""
                 bufferImage.opacity = 0
             }
         }
     }
 
     DragDrop.DropArea {
         id: dropArea
         anchors.fill: parent
 
         onDrop: {
             var mimeData = event.mimeData
             if (mimeData.hasUrls) {
                 var urls = mimeData.urls
                 for (var i = 0, j = urls.length; i < j; ++i) {
                     var url = urls[i]
                     var type = items.isDir(url) ? "folder" : "file"
                     var item = { "path":url, "type":type }
                     addItem(item)
                 }
             }
             event.accept(Qt.CopyAction)
         }
     }
 
     Item {
         id: overlay
 
         anchors.fill: parent
 
         visible: hasItems
         opacity: overlayMouseArea.containsMouse ? 1 : 0
 
         Behavior on opacity {
             NumberAnimation {}
         }
 
         PlasmaComponents.Button {
             anchors.left: parent.left
             anchors.verticalCenter: parent.verticalCenter
             enabled: (items.historyLength() > 0) && !isTransitioning
             iconSource: "arrow-left"
             onClicked: {
                 nextTimer.stop()
                 previousItem()
             }
         }
 
         PlasmaComponents.Button {
             anchors.right: parent.right
             anchors.verticalCenter: parent.verticalCenter
             enabled: hasItems && !isTransitioning
             iconSource: "arrow-right"
             onClicked: {
                 nextTimer.stop()
                 nextItem()
             }
         }
 
         Row {
             anchors.bottom: parent.bottom
             anchors.horizontalCenter: parent.horizontalCenter
             anchors.bottomMargin: units.smallSpacing
 
             /*
             PlasmaComponents.Button {
                 iconSource: "documentinfo"
                 onClicked: {  }
             }
             */
             PlasmaComponents.Button {
 
                 //text: activeSource.split("/").pop().slice(-25)
                 iconSource: "document-preview"
                 onClicked: Qt.openUrlExternally(main.activeSource)
                 //tooltip: activeSource
             }
             /*
             PlasmaComponents.Button {
                 iconSource: "trash-empty"
                 onClicked: {  }
             }
 
             PlasmaComponents.Button {
                 iconSource: "flag-black"
                 onClicked: {  }
             }
             */
         }
 
         // BUG TODO Fix overlay so _all_ mouse events reach lower components
         MouseArea {
             id: overlayMouseArea
 
             anchors.fill: parent
             hoverEnabled: true
 
             propagateComposedEvents: true
 
             //onClicked: mouse.accepted = false;
             onPressed: mouse.accepted = false;
             //onReleased: mouse.accepted = false;
             onDoubleClicked: mouse.accepted = false;
             //onPositionChanged: mouse.accepted = false;
             //onPressAndHold: mouse.accepted = false;
 
         }
 
     }
 
     // Visualization of the count down
     // TODO Makes plasmashell suck CPU until the universe or the computer collapse in on itself
     /*
     Rectangle {
         id: progress
 
         visible: plasmoid.configuration.showCountdown && hasItems && itemCount > 1
 
         color: "transparent"
 
         implicitWidth: units.gridUnit
         implicitHeight: implicitWidth
 
         Rectangle {
             anchors.fill: parent
 
             opacity:  pause ? 0.1 : 0.5
 
             radius: width / 2
             color: "gray"
 
             Rectangle {
                 id: innerRing
                 anchors.fill: parent
 
                 scale: 0
 
                 radius: width / 2
 
                 color: "lightblue"
 
                 ScaleAnimator on scale {
                     running: nextTimer.running
                     loops: Animation.Infinite
                     from: 0;
                     to: 1;
                     duration: nextTimer.interval
                 }
 
             }
         }
 
         PlasmaCore.IconItem {
             id: pauseIcon
             visible: pause
             anchors.fill: parent
             source: "media-playback-pause"
             colorGroup: PlasmaCore.ColorScope.colorGroup
         }
     }
     */
 
     PlasmaComponents.Button {
 
         anchors.centerIn: parent
 
         visible: !hasItems
         iconSource: "configure"
-        text: i18n("Configure plasmoid...")
+        text: i18nc("@action:button", "Configure...")
         onClicked: {
             plasmoid.action("configure").trigger();
         }
     }
 
     Connections {
         target: plasmoid
         onExternalData: {
             var type = items.isDir(data) ? "folder" : "file";
             var item = {
                 "path": data,
                 "type": type
             };
 
             addItem(item);
         }
     }
 }