diff --git a/libs/widgets/KoLineStyleModel.cpp b/libs/widgets/KoLineStyleModel.cpp
index 6260d17b74..eb030806f2 100644
--- a/libs/widgets/KoLineStyleModel.cpp
+++ b/libs/widgets/KoLineStyleModel.cpp
@@ -1,101 +1,107 @@
 /* This file is part of the KDE project
  * Copyright (C) 2007 Jan Hambrecht <jaham@gmx.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library 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
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "KoLineStyleModel_p.h"
 
 #include <QPen>
 
 KoLineStyleModel::KoLineStyleModel(QObject *parent)
     : QAbstractListModel(parent),
     m_hasTempStyle(false)
 {
     // add standard dash patterns
     for (int i = Qt::NoPen; i < Qt::CustomDashLine; i++) {
         QPen pen(static_cast<Qt::PenStyle>(i));
         m_styles << pen.dashPattern();
     }
 }
 
 int KoLineStyleModel::rowCount(const QModelIndex &/*parent*/) const
 {
     return m_styles.count() + (m_hasTempStyle ? 1 : 0);
 }
 
 QVariant KoLineStyleModel::data(const QModelIndex &index, int role) const
 {
     if (!index.isValid())
          return QVariant();
 
     switch(role) {
     case Qt::DecorationRole: {
         QPen pen(Qt::black);
         pen.setWidth(2);
         if (index.row() < Qt::CustomDashLine)
             pen.setStyle(static_cast<Qt::PenStyle>(index.row()));
         else if (index.row() < m_styles.count())
             pen.setDashPattern(m_styles[index.row()]);
         else if (m_hasTempStyle)
             pen.setDashPattern(m_tempStyle);
         else
             pen.setStyle(Qt::NoPen);
 
         return QVariant(pen);
     }
     case Qt::SizeHintRole:
         return QSize(100, 15);
     default:
         return QVariant();
     }
 }
 
 bool KoLineStyleModel::addCustomStyle(const QVector<qreal> &style)
 {
     if (m_styles.contains(style))
         return false;
 
     m_styles.append(style);
     return true;
 }
 
 int KoLineStyleModel::setLineStyle(Qt::PenStyle style, const QVector<qreal> &dashes)
 {
     // check if we select a standard or custom style
     if (style < Qt::CustomDashLine) {
         // a standard style
         m_hasTempStyle = false;
-        reset();
+        beginResetModel();
+        endResetModel();
+
         return style;
     } else if (style == Qt::CustomDashLine) {
         // a custom style -> check if already added
         int index = m_styles.indexOf(dashes, Qt::CustomDashLine);
         if (index < 0) {
             // not already added -> add temporarly
             m_tempStyle = dashes;
             m_hasTempStyle = true;
-            reset();
+            beginResetModel();
+            endResetModel();
+
             return m_styles.count();
         } else {
             // already added -> return index
             m_hasTempStyle = false;
-            reset();
+            beginResetModel();
+            endResetModel();
+
             return index;
         }
     }
     return -1;
 }
diff --git a/libs/widgets/KoResourceModel.cpp b/libs/widgets/KoResourceModel.cpp
index a423abde35..194e90af38 100644
--- a/libs/widgets/KoResourceModel.cpp
+++ b/libs/widgets/KoResourceModel.cpp
@@ -1,325 +1,327 @@
 /* This file is part of the KDE project
  * Copyright (C) 2008-2009 Jan Hambrecht <jaham@gmx.net>
  * Copyright (c) 2013 Sascha Suelzer <s.suelzer@gmail.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library 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
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "KoResourceModel.h"
 
 #include <klocalizedstring.h>
 #include <kconfiggroup.h>
 #include <ksharedconfig.h>
 
 #include <KoResourceServerAdapter.h>
 #include <math.h>
 
 KoResourceModel::KoResourceModel(QSharedPointer<KoAbstractResourceServerAdapter> resourceAdapter, QObject * parent)
     : KoResourceModelBase(parent)
     , m_resourceAdapter(resourceAdapter)
     , m_columnCount(4)
 {
     Q_ASSERT(m_resourceAdapter);
     m_resourceAdapter->connectToResourceServer();
     connect(m_resourceAdapter.data(), SIGNAL(resourceAdded(KoResource*)),
             this, SLOT(resourceAdded(KoResource*)));
     connect(m_resourceAdapter.data(), SIGNAL(removingResource(KoResource*)),
             this, SLOT(resourceRemoved(KoResource*)));
     connect(m_resourceAdapter.data(), SIGNAL(resourceChanged(KoResource*)),
             this, SLOT(resourceChanged(KoResource*)));
     connect(m_resourceAdapter.data(), SIGNAL(tagsWereChanged()),
             this, SLOT(tagBoxEntryWasModified()));
     connect(m_resourceAdapter.data(), SIGNAL(tagCategoryWasAdded(QString)),
             this, SLOT(tagBoxEntryWasAdded(QString)));
     connect(m_resourceAdapter.data(), SIGNAL(tagCategoryWasRemoved(QString)),
             this, SLOT(tagBoxEntryWasRemoved(QString)));
 }
 
 KoResourceModel::~KoResourceModel()
 {
     if (!m_currentTag.isEmpty()) {
         KConfigGroup group =  KSharedConfig::openConfig()->group("SelectedTags");
         group.writeEntry(serverType(), m_currentTag);
     }
 
 }
 
 int KoResourceModel::rowCount( const QModelIndex &/*parent*/ ) const
 {
     int resourceCount = m_resourceAdapter->resources().count();
     if (!resourceCount)
         return 0;
 
     return static_cast<int>(ceil(static_cast<qreal>(resourceCount) / m_columnCount));
 }
 
 int KoResourceModel::columnCount ( const QModelIndex & ) const
 {
     return m_columnCount;
 }
 
 QVariant KoResourceModel::data( const QModelIndex &index, int role ) const
 {
     if( ! index.isValid() )
          return QVariant();
 
     switch( role )
     {
         case Qt::DisplayRole:
         {
             KoResource * resource = static_cast<KoResource*>(index.internalPointer());
             if( ! resource )
                 return QVariant();
             QString resName = i18n( resource->name().toUtf8().data());
 
             return QVariant( resName );
         }
         case KoResourceModel::TagsRole:
         {
             KoResource * resource = static_cast<KoResource*>(index.internalPointer());
             if( ! resource )
                 return QVariant();
             if (m_resourceAdapter->assignedTagsList(resource).count()) {
                 QString taglist = m_resourceAdapter->assignedTagsList(resource).join("</li><li>");
                 return QString("<li>%2</li>").arg(taglist);
             } else {
                 return QString();
             }
         }
         case Qt::DecorationRole:
         {
             KoResource * resource = static_cast<KoResource*>(index.internalPointer());
             if( ! resource )
                 return QVariant();
 
             return QVariant( resource->image() );
         }
         case KoResourceModel::LargeThumbnailRole:
         {
             KoResource * resource = static_cast<KoResource*>(index.internalPointer());
             if( ! resource )
                 return QVariant();
 
             QSize imageSize = resource->image().size();
             QSize thumbSize( 100, 100 );
             if(imageSize.height() > thumbSize.height() || imageSize.width() > thumbSize.width()) {
                 qreal scaleW = static_cast<qreal>( thumbSize.width() ) / static_cast<qreal>( imageSize.width() );
                 qreal scaleH = static_cast<qreal>( thumbSize.height() ) / static_cast<qreal>( imageSize.height() );
 
                 qreal scale = qMin( scaleW, scaleH );
 
                 int thumbW = static_cast<int>( imageSize.width() * scale );
                 int thumbH = static_cast<int>( imageSize.height() * scale );
 
                 return QVariant(resource->image().scaled( thumbW, thumbH, Qt::IgnoreAspectRatio, Qt::SmoothTransformation));
             }
             else
                 return QVariant(resource->image());
         }
 
         default:
             return QVariant();
     }
 }
 
 QModelIndex KoResourceModel::index ( int row, int column, const QModelIndex & ) const
 {
     int index = row * m_columnCount + column;
     const QList<KoResource*> resources = m_resourceAdapter->resources();
     if( index >= resources.count() || index < 0)
         return QModelIndex();
 
     return createIndex( row, column, resources[index] );
 }
 
 void KoResourceModel::doSafeLayoutReset(KoResource *activateAfterReformat)
 {
     emit beforeResourcesLayoutReset(activateAfterReformat);
-    reset();
+    beginResetModel();
+    endResetModel();
     emit afterResourcesLayoutReset();
 }
 
 void KoResourceModel::setColumnCount( int columnCount )
 {
     if (columnCount != m_columnCount) {
         emit beforeResourcesLayoutReset(0);
         m_columnCount = columnCount;
-        reset();
+        beginResetModel();
+        endResetModel();
         emit afterResourcesLayoutReset();
     }
 }
 
 void KoResourceModel::resourceAdded(KoResource *resource)
 {
     int newIndex = m_resourceAdapter->resources().indexOf(resource);
     if (newIndex >= 0) {
         doSafeLayoutReset(0);
     }
 }
 
 void KoResourceModel::resourceRemoved(KoResource *resource)
 {
     Q_UNUSED(resource);
     doSafeLayoutReset(0);
 }
 
 void KoResourceModel::resourceChanged(KoResource* resource)
 {
     int resourceIndex = m_resourceAdapter->resources().indexOf(resource);
     int row = resourceIndex / columnCount();
     int column = resourceIndex % columnCount();
 
     QModelIndex modelIndex = index(row, column);
     if (!modelIndex.isValid()) {
         return;
     }
 
     emit dataChanged(modelIndex, modelIndex);
 }
 
 void KoResourceModel::tagBoxEntryWasModified()
 {
     m_resourceAdapter->updateServer();
     emit tagBoxEntryModified();
 }
 
 void KoResourceModel::tagBoxEntryWasAdded(const QString& tag)
 {
     emit tagBoxEntryAdded(tag);
 }
 
 void KoResourceModel::tagBoxEntryWasRemoved(const QString& tag)
 {
     emit tagBoxEntryRemoved(tag);
 }
 
 QModelIndex KoResourceModel::indexFromResource(KoResource* resource) const
 {
     int resourceIndex = m_resourceAdapter->resources().indexOf(resource);
     if (columnCount() > 0) {
         int row = resourceIndex / columnCount();
         int column = resourceIndex % columnCount();
         return index(row, column);
     }
     return QModelIndex();
 }
 
 QString KoResourceModel::extensions() const
 {
     return m_resourceAdapter->extensions();
 }
 
 void KoResourceModel::importResourceFile(const QString &filename)
 {
     m_resourceAdapter->importResourceFile(filename);
 }
 
 void KoResourceModel::importResourceFile(const QString & filename, bool fileCreation)
 {
     m_resourceAdapter->importResourceFile(filename, fileCreation);
 }
 
 bool KoResourceModel::removeResource(KoResource* resource)
 {
     return m_resourceAdapter->removeResource(resource);
 }
 
 void KoResourceModel::removeResourceFile(const QString &filename)
 {
     m_resourceAdapter->removeResourceFile(filename);
 }
 
 QStringList KoResourceModel::assignedTagsList(KoResource *resource) const
 {
     return m_resourceAdapter->assignedTagsList(resource);
 }
 
 void KoResourceModel::addTag(KoResource* resource, const QString& tag)
 {
     m_resourceAdapter->addTag(resource, tag);
     emit tagBoxEntryAdded(tag);
 }
 
 void KoResourceModel::deleteTag(KoResource *resource, const QString &tag)
 {
     m_resourceAdapter->deleteTag(resource, tag);
 }
 
 QStringList KoResourceModel::tagNamesList() const
 {
     return m_resourceAdapter->tagNamesList();
 }
 
 QStringList KoResourceModel::searchTag(const QString& lineEditText)
 {
     return m_resourceAdapter->searchTag(lineEditText);
 }
 
 void KoResourceModel::searchTextChanged(const QString& searchString)
 {
     m_resourceAdapter->searchTextChanged(searchString);
 }
 
 void KoResourceModel::enableResourceFiltering(bool enable)
 {
     m_resourceAdapter->enableResourceFiltering(enable);
 }
 
 void KoResourceModel::setCurrentTag(const QString& currentTag)
 {
     m_currentTag = currentTag;
     m_resourceAdapter->setCurrentTag(currentTag);
 }
 
 void KoResourceModel::updateServer()
 {
     m_resourceAdapter->updateServer();
 }
 
 int KoResourceModel::resourcesCount() const
 {
     return m_resourceAdapter->resources().count();
 }
 
 QList<KoResource *> KoResourceModel::currentlyVisibleResources() const
 {
   return m_resourceAdapter->resources();
 }
 
 void KoResourceModel::tagCategoryMembersChanged()
 {
     m_resourceAdapter->tagCategoryMembersChanged();
 }
 
 void KoResourceModel::tagCategoryAdded(const QString& tag)
 {
     m_resourceAdapter->tagCategoryAdded(tag);
 }
 
 void KoResourceModel::tagCategoryRemoved(const QString& tag)
 {
     m_resourceAdapter->tagCategoryRemoved(tag);
 }
 
 QString KoResourceModel::serverType() const
 {
     return m_resourceAdapter->serverType();
 }
 
 QList< KoResource* > KoResourceModel::serverResources() const
 {
     return m_resourceAdapter->serverResources();
 }
diff --git a/libs/widgets/kis_file_name_requester.cpp b/libs/widgets/kis_file_name_requester.cpp
index db21da770e..966cc46999 100644
--- a/libs/widgets/kis_file_name_requester.cpp
+++ b/libs/widgets/kis_file_name_requester.cpp
@@ -1,103 +1,103 @@
 /*
  *  Copyright (c) 2015 Dmitry Kazakov <dimula73@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 02110-1301, USA.
  */
 
 #include "kis_file_name_requester.h"
 #include "ui_wdg_file_name_requester.h"
 
-#include <QDesktopServices>
+#include <QStandardPaths>
 #include <QDebug>
 
 #include "KoIcon.h"
 
 KisFileNameRequester::KisFileNameRequester(QWidget *parent)
     : QWidget(parent)
     , m_ui(new Ui::WdgFileNameRequester)
     , m_mode(KoFileDialog::OpenFile)
 {
     m_ui->setupUi(this);
 
     m_ui->btnSelectFile->setIcon(kisIcon("folder"));
 
     connect(m_ui->btnSelectFile, SIGNAL(clicked()), SLOT(slotSelectFile()));
     connect(m_ui->txtFileName, SIGNAL(textChanged(const QString&)), SIGNAL(textChanged(const QString&)));
 }
 
 KisFileNameRequester::~KisFileNameRequester()
 {
 }
 
 void KisFileNameRequester::setStartDir(const QString &path)
 {
     m_basePath = path;
 }
 
 void KisFileNameRequester::setFileName(const QString &path)
 {
     m_ui->txtFileName->setText(path);
     emit fileSelected(path);
 }
 
 QString KisFileNameRequester::fileName() const
 {
     return m_ui->txtFileName->text();
 }
 
 void KisFileNameRequester::setMode(KoFileDialog::DialogType mode)
 {
     m_mode = mode;
 }
 
 KoFileDialog::DialogType KisFileNameRequester::mode() const
 {
     return m_mode;
 }
 
 void KisFileNameRequester::setMimeTypeFilters(const QStringList &filterList,
                                               QString defaultFilter)
 {
     m_mime_filter_list = filterList;
     m_mime_default_filter = defaultFilter;
 }
 
 void KisFileNameRequester::slotSelectFile()
 {
     KoFileDialog dialog(this, m_mode, "OpenDocument");
     if (m_mode == KoFileDialog::OpenFile)
     {
         dialog.setCaption(i18n("Select a file to load..."));
     }
     else if (m_mode == KoFileDialog::OpenDirectory)
     {
         dialog.setCaption(i18n("Select a directory to load..."));
     }
     if (m_basePath.isEmpty()) {
-        dialog.setDefaultDir(QDesktopServices::storageLocation(QDesktopServices::PicturesLocation));
+        dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
     }
     else {
         dialog.setDefaultDir(m_basePath);
     }
 
     Q_ASSERT(!m_mime_filter_list.isEmpty());
     dialog.setMimeTypeFilters(m_mime_filter_list, m_mime_default_filter);
 
     QString newFileName = dialog.filename();
 
     if (!newFileName.isEmpty()) {
         setFileName(newFileName);
     }
 }