diff --git a/importer/importer.cpp b/importer/importer.cpp
index 3b10e69e..665805a4 100644
--- a/importer/importer.cpp
+++ b/importer/importer.cpp
@@ -1,278 +1,278 @@
 // vim: set tabstop=4 shiftwidth=4 expandtab:
 /*
 Gwenview: an image viewer
 Copyright 2009 Aurélien Gâteau <agateau@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) 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, Cambridge, MA 02110-1301, USA.
 
 */
 // Self
 #include "importer.h"
 
 // Qt
 #include <QDateTime>
 #include <QDebug>
 #include <QUrl>
 #include <QTemporaryDir>
 
 // KDE
 #include <KFileItem>
 #include <KIO/CopyJob>
 #include <KIO/DeleteJob>
 #include <KIO/MkpathJob>
 #include <KIO/Job>
 #include <KIO/JobUiDelegate>
 #include <KJobWidgets>
 #include <KLocalizedString>
 
 // stdc++
 #include <memory>
 
 // Local
 #include <fileutils.h>
 #include <filenameformater.h>
 #include <lib/timeutils.h>
 #include <QDir>
 
 namespace Gwenview
 {
 
 struct ImporterPrivate
 {
     Importer* q;
     QWidget* mAuthWindow;
     std::unique_ptr<FileNameFormater> mFileNameFormater;
     QUrl mTempImportDirUrl;
     QTemporaryDir* mTempImportDir;
 
     /* @defgroup reset Should be reset in start()
      * @{ */
     QList<QUrl> mUrlList;
     QList<QUrl> mImportedUrlList;
     QList<QUrl> mSkippedUrlList;
     QList<QUrl> mFailedUrlList;
     QList<QUrl> mFailedSubFolderList;
     int mRenamedCount;
     int mProgress;
     int mJobProgress;
     /* @} */
 
     QUrl mCurrentUrl;
 
     bool createImportDir(const QUrl& url)
     {
         Q_ASSERT(url.isLocalFile());
         // FIXME: Support remote urls
 
         if (!QDir().mkpath(url.toLocalFile())) {
             emit q->error(i18n("Could not create destination folder."));
             return false;
         }
         
         QString tempDirPath = url.toLocalFile() + "/.gwenview_importer-XXXXXX";
         mTempImportDir = new QTemporaryDir(tempDirPath);
                     
         if (!mTempImportDir->isValid()) {
             emit q->error(i18n("Could not create temporary upload folder."));
             return false;
         }
         
         mTempImportDirUrl = QUrl::fromLocalFile(mTempImportDir->path() + '/');
         if (!mTempImportDirUrl.isValid()) {
             emit q->error(i18n("Could not create temporary upload folder."));
             return false;
         }         
         
         return true;
     }
 
     void importNext()
     {
         if (mUrlList.empty()) {
             q->finalizeImport();
             return;
         }
         mCurrentUrl = mUrlList.takeFirst();
         QUrl dst = mTempImportDirUrl;
         dst.setPath(dst.path() + mCurrentUrl.fileName());
-        KIO::Job* job = KIO::copy(mCurrentUrl, dst, KIO::HideProgressInfo);
+        KIO::Job* job = KIO::copy(mCurrentUrl, dst, KIO::HideProgressInfo|KIO::Overwrite);
         KJobWidgets::setWindow(job, mAuthWindow);
         QObject::connect(job, &KJob::result,
                          q, &Importer::slotCopyDone);
         QObject::connect(job, SIGNAL(percent(KJob*,ulong)),
                          q, SLOT(slotPercent(KJob*,ulong)));
     }
 
     void renameImportedUrl(const QUrl& src)
     {
         QUrl dst = src.resolved(QUrl(".."));
         QString fileName;
         if (mFileNameFormater.get()) {
             KFileItem item(src);
             item.setDelayedMimeTypes(true);
             // Get the document time, but do not cache the result because the
             // 'src' url is temporary: if we import "foo/image.jpg" and
             // "bar/image.jpg", both images will be temporarily saved in the
             // 'src' url.
             QDateTime dateTime = TimeUtils::dateTimeForFileItem(item, TimeUtils::SkipCache);
             fileName = mFileNameFormater->format(src, dateTime);
         } else {
             fileName = src.fileName();
         }
         dst.setPath(dst.path() + fileName);
 
         FileUtils::RenameResult result;
         // Create additional subfolders if needed (e.g. when extra slashes in FileNameFormater)
         QUrl subFolder = dst.adjusted(QUrl::RemoveFilename);
         KIO::Job* job = KIO::mkpath(subFolder, QUrl(), KIO::HideProgressInfo);
         KJobWidgets::setWindow(job,mAuthWindow);
         if (!job->exec()) { // if subfolder creation fails
             qWarning() << "Could not create subfolder:" << subFolder;
             if (!mFailedSubFolderList.contains(subFolder)) {
                 mFailedSubFolderList << subFolder;
             }
             result = FileUtils::RenameFailed;
         } else { // if subfolder creation succeeds
             result = FileUtils::rename(src, dst, mAuthWindow);
         }
 
         switch (result) {
         case FileUtils::RenamedOK:
             mImportedUrlList << mCurrentUrl;
             break;
         case FileUtils::RenamedUnderNewName:
             mRenamedCount++;
             mImportedUrlList << mCurrentUrl;
             break;
         case FileUtils::Skipped:
             mSkippedUrlList << mCurrentUrl;
             break;
         case FileUtils::RenameFailed:
             mFailedUrlList << mCurrentUrl;
             qWarning() << "Rename failed for" << mCurrentUrl;
         }
         q->advance();
         importNext();
     }
 };
 
 Importer::Importer(QWidget* parent)
 : QObject(parent)
 , d(new ImporterPrivate)
 {
     d->q = this;
     d->mAuthWindow = parent;
 }
 
 Importer::~Importer()
 {
     delete d;
 }
 
 void Importer::setAutoRenameFormat(const QString& format)
 {
     if (format.isEmpty()) {
         d->mFileNameFormater.reset(nullptr);
     } else {
         d->mFileNameFormater.reset(new FileNameFormater(format));
     }
 }
 
 void Importer::start(const QList<QUrl>& list, const QUrl& destination)
 {
     d->mUrlList = list;
     d->mImportedUrlList.clear();
     d->mSkippedUrlList.clear();
     d->mFailedUrlList.clear();
     d->mFailedSubFolderList.clear();
     d->mRenamedCount = 0;
     d->mProgress = 0;
     d->mJobProgress = 0;
 
     emitProgressChanged();
     emit maximumChanged(d->mUrlList.count() * 100);
 
     if (!d->createImportDir(destination)) {
         qWarning() << "Could not create import dir";
         return;
     }
     d->importNext();
 }
 
 void Importer::slotCopyDone(KJob* _job)
 {
     KIO::CopyJob* job = static_cast<KIO::CopyJob*>(_job);
     QUrl url = job->destUrl();
     if (job->error()) {
         // Add document to failed url list and proceed with next one
         d->mFailedUrlList << d->mCurrentUrl;
         advance();
         d->importNext();
         return;
     }
 
     d->renameImportedUrl(url);
 }
 
 void Importer::finalizeImport()
 {
     delete d->mTempImportDir;
     emit importFinished();
 }
 
 void Importer::advance()
 {
     ++d->mProgress;
     d->mJobProgress = 0;
     emitProgressChanged();
 }
 
 void Importer::slotPercent(KJob*, unsigned long percent)
 {
     d->mJobProgress = percent;
     emitProgressChanged();
 }
 
 void Importer::emitProgressChanged()
 {
     emit progressChanged(d->mProgress * 100 + d->mJobProgress);
 }
 
 QList<QUrl> Importer::importedUrlList() const
 {
     return d->mImportedUrlList;
 }
 
 QList<QUrl> Importer::skippedUrlList() const
 {
     return d->mSkippedUrlList;
 }
 
 QList<QUrl> Importer::failedUrlList() const
 {
     return d->mFailedUrlList;
 }
 
 QList<QUrl> Importer::failedSubFolderList() const
 {
     return d->mFailedSubFolderList;
 }
 
 int Importer::renamedCount() const
 {
     return d->mRenamedCount;
 }
 
 } // namespace