diff --git a/solid-device-automounter/kcm/DeviceAutomounterKCM.ui b/solid-device-automounter/kcm/DeviceAutomounterKCM.ui
index 35a0dfb61..61dd271e6 100644
--- a/solid-device-automounter/kcm/DeviceAutomounterKCM.ui
+++ b/solid-device-automounter/kcm/DeviceAutomounterKCM.ui
@@ -1,153 +1,153 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>DeviceAutomounterKCM</class>
  <widget class="QWidget" name="DeviceAutomounterKCM">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>615</width>
     <height>380</height>
    </rect>
   </property>
   <layout class="QGridLayout" name="gridLayout_2">
    <item row="0" column="0" colspan="3">
     <widget class="QCheckBox" name="automountEnabled">
      <property name="whatsThis">
       <string>When this is unchecked, no device automounting of any kind will happen, regardless of anything selected in the &quot;Device Overrides&quot; section.</string>
      </property>
      <property name="text">
       <string>Enable automatic mounting of removable media</string>
      </property>
     </widget>
    </item>
    <item row="1" column="0">
     <spacer name="horizontalSpacer">
      <property name="orientation">
       <enum>Qt::Horizontal</enum>
      </property>
      <property name="sizeType">
       <enum>QSizePolicy::Fixed</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>22</width>
        <height>76</height>
       </size>
      </property>
     </spacer>
    </item>
    <item row="1" column="1">
     <layout class="QVBoxLayout" name="verticalLayout">
      <item>
       <widget class="QCheckBox" name="automountUnknownDevices">
        <property name="whatsThis">
         <string>When this is checked, only remembered devices will be automatically mounted. A device is 'remembered' if it has ever been mounted before. For instance, plugging in a USB media player to charge is not sufficient to 'remember' it - if the files are not accessed, it will not be automatically mounted the next time it is seen. Once they have been accessed, however, the device's contents will be automatically made available to the system.</string>
        </property>
        <property name="text">
         <string>Only automatically mount removable media that has been manually mounted before</string>
        </property>
       </widget>
      </item>
      <item>
       <widget class="QCheckBox" name="automountOnLogin">
        <property name="whatsThis">
         <string>If any removable storage devices are connected to your system when you login to your desktop, their contents will automatically be made available to your system for other programs to read.</string>
        </property>
        <property name="text">
         <string>Mount all removable media at login</string>
        </property>
       </widget>
      </item>
      <item>
       <widget class="QCheckBox" name="automountOnPlugin">
        <property name="whatsThis">
         <string>When this is checked, the contents of any storage device will automatically be made available to the system when it is plugged in or attached.</string>
        </property>
        <property name="text">
         <string>Automatically mount removable media when attached</string>
        </property>
       </widget>
      </item>
     </layout>
    </item>
    <item row="1" column="2">
     <spacer name="horizontalSpacer_2">
      <property name="orientation">
       <enum>Qt::Horizontal</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>40</width>
        <height>20</height>
       </size>
      </property>
     </spacer>
    </item>
    <item row="2" column="0" colspan="3">
     <widget class="QGroupBox" name="groupBox">
      <property name="title">
-      <string>Device Overrides</string>
+      <string>Automatic mount</string>
      </property>
      <layout class="QVBoxLayout" name="verticalLayout_2">
       <item>
        <widget class="QTreeView" name="deviceView">
         <property name="whatsThis">
          <string>This list contains the storage devices known to the system. If &quot;Automount on Login&quot; is checked, the device will be automatically mounted even though &quot;Mount all removable media at login&quot; is unchecked. The same applies for &quot;Automount on Attach&quot;.
 
 If &quot;Enable automatic mounting of removable media&quot; is unchecked, the overrides do not apply and no devices will be automatically mounted.</string>
         </property>
         <property name="editTriggers">
          <set>QAbstractItemView::NoEditTriggers</set>
         </property>
         <property name="selectionMode">
          <enum>QAbstractItemView::ExtendedSelection</enum>
         </property>
         <property name="rootIsDecorated">
          <bool>true</bool>
         </property>
         <property name="itemsExpandable">
          <bool>true</bool>
         </property>
         <property name="sortingEnabled">
          <bool>true</bool>
         </property>
         <property name="animated">
          <bool>true</bool>
         </property>
         <property name="allColumnsShowFocus">
          <bool>true</bool>
         </property>
         <property name="expandsOnDoubleClick">
          <bool>false</bool>
         </property>
         <attribute name="headerShowSortIndicator" stdset="0">
          <bool>false</bool>
         </attribute>
         <attribute name="headerStretchLastSection">
          <bool>false</bool>
         </attribute>
        </widget>
       </item>
       <item>
        <layout class="QHBoxLayout" name="horizontalLayout">
         <item>
          <widget class="QPushButton" name="forgetDevice">
           <property name="whatsThis">
            <string>Clicking this button causes the selected devices to be 'forgotten'. This is only useful if &quot;Only automatically mount removable media that has been manually mounted before&quot; is checked. Once a device is forgotten and the system is set to only automatically mount familiar devices, the device will not be automatically mounted.</string>
           </property>
           <property name="text">
            <string>Forget Device</string>
           </property>
          </widget>
         </item>
        </layout>
       </item>
      </layout>
     </widget>
    </item>
   </layout>
  </widget>
  <resources/>
  <connections/>
 </ui>
diff --git a/solid-device-automounter/kcm/DeviceModel.cpp b/solid-device-automounter/kcm/DeviceModel.cpp
index 6b8f2dc39..6a48f581f 100644
--- a/solid-device-automounter/kcm/DeviceModel.cpp
+++ b/solid-device-automounter/kcm/DeviceModel.cpp
@@ -1,336 +1,336 @@
 /**************************************************************************
 *   Copyright (C) 2009-2010 Trever Fischer <tdfischer@fedoraproject.org>  *
 *   Copyright (C) 2015 Kai Uwe Broulik <kde@privat.broulik.de>            *
 *                                                                         *
 *   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  02110-1301  USA .        *
 ***************************************************************************/
 
 #include "DeviceModel.h"
 
 #include <QIcon>
 
 #include <KLocalizedString>
 #include <Solid/DeviceNotifier>
 #include <Solid/Device>
 #include <Solid/StorageVolume>
 #include <Solid/StorageAccess>
 
 #include "AutomounterSettings.h"
 
 DeviceModel::DeviceModel(QObject *parent)
     : QAbstractItemModel(parent)
 {
     reload();
     
     connect(Solid::DeviceNotifier::instance(), &Solid::DeviceNotifier::deviceAdded, this, &DeviceModel::deviceAttached);
     connect(Solid::DeviceNotifier::instance(), &Solid::DeviceNotifier::deviceRemoved, this, &DeviceModel::deviceRemoved);
 }
 
 void DeviceModel::forgetDevice(const QString &udi)
 {
     if (m_disconnected.contains(udi)) {
         const int deviceIndex = m_disconnected.indexOf(udi);
         beginRemoveRows(index(1, 0), deviceIndex, deviceIndex);
         m_disconnected.removeOne(udi);
         endRemoveRows();
     } else if (m_attached.contains(udi)) {
         const int deviceIndex = m_attached.indexOf(udi);
         beginRemoveRows(index(0, 0), deviceIndex, deviceIndex);
         m_attached.removeOne(udi);
         endRemoveRows();
     }
     m_loginForced.remove(udi);
     m_attachedForced.remove(udi);
 }
 
 QVariant DeviceModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
     if (orientation == Qt::Horizontal && role == Qt::DisplayRole) {
         switch(section) {
         case 0: return i18n("Device");
-        case 1: return i18n("Automount on Login");
-        case 2: return i18n("Automount on Attach");
+        case 1: return i18nc("As in automount on login", "On Login");
+        case 2: return i18nc("As in automoount on attach", "On Attach");
         }
     }
     return QVariant();
 }
 
 void DeviceModel::deviceAttached(const QString &udi)
 {
     const Solid::Device devive(udi);
     auto volume = devive.as<Solid::StorageVolume>();
 
     if (volume && !volume->isIgnored()) {
         if (m_disconnected.contains(udi)) {
             const int deviceIndex = m_disconnected.indexOf(udi);
             beginRemoveRows(index(1, 0), deviceIndex, deviceIndex);
             m_disconnected.removeOne(udi);
             endRemoveRows();
         }
 
         addNewDevice(udi);
     }
 }
 
 void DeviceModel::deviceRemoved(const QString &udi)
 {
     if (m_attached.contains(udi)) {
         const int deviceIndex = m_attached.indexOf(udi);
 
         beginRemoveRows(index(0, 0), deviceIndex, deviceIndex);
         m_attached.removeOne(udi);
         endRemoveRows();
 
         // NOTE the device is not moved to the "Disconnected" section
         // when removing it while the KCM is opened because we need to check
         // whether the device that just got detached is ignored
         // (don't show partition tables and other garbage) but this information
         // is no longer available when the device is gone
     }
 }
 
 void DeviceModel::addNewDevice(const QString &udi)
 {
     AutomounterSettings::self()->load();
 
     if (!m_loginForced.contains(udi)) {
         m_loginForced[udi] = AutomounterSettings::deviceAutomountIsForced(udi, AutomounterSettings::Login);
     }
     if (!m_attachedForced.contains(udi)) {
         m_loginForced[udi] = AutomounterSettings::deviceAutomountIsForced(udi, AutomounterSettings::Attach);
     }
 
     const Solid::Device dev(udi);
     if (dev.isValid()) {
         if (dev.is<Solid::StorageAccess>()) {
             const Solid::StorageAccess *access = dev.as<Solid::StorageAccess>();
             if (!access->isIgnored() || !access->isAccessible()) {
                 beginInsertRows(index(0, 0), m_attached.size(), m_attached.size());
                 m_attached << udi;
                 endInsertRows();
             }
         }
     } else {
         beginInsertRows(index(1, 0), m_disconnected.size(), m_disconnected.size());
         m_disconnected << udi;
         endInsertRows();
     }
 }
 
 void DeviceModel::reload()
 {
     beginResetModel();
     m_loginForced.clear();
     m_attachedForced.clear();
     m_attached.clear();
     m_disconnected.clear();
 
     foreach (const QString &dev, AutomounterSettings::knownDevices()) {
         addNewDevice(dev);
     }
     foreach (const QString &udi, m_loginForced.keys()) {
         m_loginForced[udi] = AutomounterSettings::deviceAutomountIsForced(udi, AutomounterSettings::Login);
         m_attachedForced[udi] = AutomounterSettings::deviceAutomountIsForced(udi, AutomounterSettings::Attach);
     }
     endResetModel();
 }
 
 QModelIndex DeviceModel::index(int row, int column, const QModelIndex &parent) const
 {
     if (parent.isValid()) {
         if (parent.column() > 0) {
             return QModelIndex();
         }
 
         if (parent.row() == 0) {
             if (row >= 0 && row < m_attached.size() && column >= 0 && column <= 2) {
                 return createIndex(row, column, static_cast<quintptr>(0));
             }
         } else if (parent.row() == 1) {
             if (row >= 0 && row < m_disconnected.size() && column >= 0 && column <= 2) {
                 return createIndex(row, column, 1);
             }
         }
     } else {
          if ((row == 0 || row == 1) && column >= 0 && column <= 2) {
             return createIndex(row, column, 3);
          }
     }
     return QModelIndex();
 }
 
 QModelIndex DeviceModel::parent(const QModelIndex &index) const
 {
     if (index.isValid()) {
         if (index.internalId() == 3)
             return QModelIndex();
         return createIndex(index.internalId(), 0, 3);
     }
     return QModelIndex();
 }
 
 Qt::ItemFlags DeviceModel::flags(const QModelIndex &index) const
 {
     if (index.isValid()) {
         if (index.parent().isValid()) {
             if (index.column() > 0) {
                 return Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsUserCheckable;
             } else if (index.column() == 0) {
                 return Qt::ItemIsSelectable | Qt::ItemIsEnabled;
             }
         } else {
             return Qt::ItemIsEnabled;
         }
     }
 
     return Qt::NoItemFlags;
 }
 
 bool DeviceModel::setData(const QModelIndex &index, const QVariant &value, int role)
 {
     if (index.isValid() && role == Qt::CheckStateRole && index.column() > 0) {
         const QString &udi = index.data(Qt::UserRole).toString();
         switch(index.column()) {
         case 1:
             m_loginForced[udi] = (value.toInt() == Qt::Checked) ? true : false;
             break;
         case 2:
             m_attachedForced[udi] = (value.toInt() == Qt::Checked) ? true : false;
             break;
         }
         emit dataChanged(index, index);
         return true;
     }
 
     return false;
 }
 
 QVariant DeviceModel::data(const QModelIndex &index, int role) const
 {
     if (index.isValid() && index.parent().isValid()) {
         if (index.parent().row() == 0) {
             if (role == TypeRole) {
 				return Attached;
             }
 
             const QString &udi = m_attached.at(index.row());
             Solid::Device dev(udi);
 
             if (role == Qt::UserRole) {
                 return udi;
             }
 
             if (index.column() == 0) {
                 switch(role) {
                 case Qt::DisplayRole:
                     return dev.description();
                 case Qt::ToolTipRole:
                     return i18n("UDI: %1", udi);
                 case Qt::DecorationRole:
                     return QIcon::fromTheme(dev.icon());
                 }
             } else if (index.column() == 1) {
                 switch(role) {
                 case Qt::CheckStateRole:
                     return m_loginForced[udi] ? Qt::Checked : Qt::Unchecked;
                 case Qt::ToolTipRole:
                     if (m_loginForced[udi] || AutomounterSettings::shouldAutomountDevice(udi, AutomounterSettings::Login))
                         return i18n("This device will be automatically mounted at login.");
                     return i18n("This device will not be automatically mounted at login.");
                 }
             } else if (index.column() == 2) {
                 switch(role) {
                 case Qt::CheckStateRole:
                     return m_attachedForced[udi] ? Qt::Checked : Qt::Unchecked;
                 case Qt::ToolTipRole:
                     if (m_attachedForced[udi] || AutomounterSettings::shouldAutomountDevice(udi, AutomounterSettings::Attach))
                         return i18n("This device will be automatically mounted when attached.");
                     return i18n("This device will not be automatically mounted when attached.");
                 }
             }
         } else if (index.parent().row() == 1) {
             if (role == TypeRole) {
 				return Detatched;
             }
 
             const QString &udi = m_disconnected[index.row()];
 
             if (role == Qt::UserRole) {
                 return udi;
             }
 
             if (index.column() == 0) {
                 switch(role) {
                 case Qt::DisplayRole:
                     return AutomounterSettings::getDeviceName(udi);
                 case Qt::ToolTipRole:
                     return i18n("UDI: %1", udi);
                 case Qt::DecorationRole:
                     return QIcon::fromTheme(AutomounterSettings::getDeviceIcon(udi));
                 }
             } else if (index.column() == 1) {
                 switch(role) {
                 case Qt::CheckStateRole:
                     return m_loginForced[udi] ? Qt::Checked : Qt::Unchecked;
                 case Qt::ToolTipRole:
                     if (m_loginForced[udi] || AutomounterSettings::shouldAutomountDevice(udi, AutomounterSettings::Login))
                         return i18n("This device will be automatically mounted at login.");
                     return i18n("This device will not be automatically mounted at login.");
                 }
             } else if (index.column() == 2) {
                 switch(role) {
                 case Qt::CheckStateRole:
                     return m_attachedForced[udi] ? Qt::Checked : Qt::Unchecked;
                 case Qt::ToolTipRole:
                     if (m_attachedForced[udi] || AutomounterSettings::shouldAutomountDevice(udi, AutomounterSettings::Attach))
                         return i18n("This device will be automatically mounted when attached.");
                     return i18n("This device will not be automatically mounted when attached.");
                 }
             }
         }
     } else if (index.isValid()) {
         if (role == Qt::DisplayRole && index.column() == 0) {
             if (index.row() == 0) {
                 return i18n("Attached Devices");
             } else if (index.row() == 1) {
                 return i18n("Disconnected Devices");
             }
         }
     }
     return QVariant();
 }
 
 int DeviceModel::rowCount(const QModelIndex &parent) const
 {
     if (parent.isValid()) {
         if (parent.internalId() < 3 || parent.column() > 0) {
             return 0;
         }
         if (parent.row() == 0) {
             return m_attached.size();
         }
 
         return m_disconnected.size();
     }
 
     return 2;
 }
 
 int DeviceModel::columnCount(const QModelIndex &parent) const
 {
     Q_UNUSED(parent);
     return 3;
 }