diff --git a/core/dplugins/generic/view/slideshow/common/slideshowloader.cpp b/core/dplugins/generic/view/slideshow/common/slideshowloader.cpp
index 1079d71529..8b97d99a8a 100644
--- a/core/dplugins/generic/view/slideshow/common/slideshowloader.cpp
+++ b/core/dplugins/generic/view/slideshow/common/slideshowloader.cpp
@@ -1,842 +1,842 @@
 /* ============================================================
  *
  * This file is a part of digiKam project
  * https://www.digikam.org
  *
  * Date        : 2005-04-21
  * Description : slide show tool using preview of pictures.
  *
  * Copyright (C) 2005-2020 by Gilles Caulier <caulier dot gilles at gmail dot com>
  * Copyright (C)      2004 by Enrico Ros <eros dot kde at email dot it>
  * Copyright (C) 2019-2020 by Minh Nghia Duong <minhnghiaduong997 at gmail dot 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, 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.
  *
  * ============================================================ */
 
 #include "slideshowloader.h"
 #include "digikam_config.h"
 
 // Qt includes
 
 #include <QMimeDatabase>
 #include <QApplication>
 #include <QWheelEvent>
 #include <QMouseEvent>
 #include <QPaintEvent>
 #include <QKeyEvent>
 #include <QScreen>
 #include <QWindow>
 #include <QCursor>
 #include <QTimer>
 #include <QColor>
 #include <QFont>
 
 #ifdef HAVE_DBUS
 #   include <QDBusConnection>
 #   include <QDBusMessage>
 #   include <QDBusReply>
 #endif
 
 // KDE includes
 
 #include <klocalizedstring.h>
 
 // Local includes
 
 #include "digikam_debug.h"
 #include "slidetoolbar.h"
 #include "slideimage.h"
 #include "slideerror.h"
 #include "slideosd.h"
 #include "slideend.h"
 
 #ifdef HAVE_MEDIAPLAYER
 #   include "slidevideo.h"
 #endif //HAVE_MEDIAPLAYER
 
 using namespace Digikam;
 
 namespace DigikamGenericSlideShowPlugin
 {
 
 class Q_DECL_HIDDEN SlideShowLoader::Private
 {
 
 public:
 
     explicit Private()
         : fileIndex(-1),
           screenSaverCookie(-1),
           mouseMoveTimer(nullptr),
           imageView(nullptr),
 
 #ifdef HAVE_MEDIAPLAYER
 
           videoView(nullptr),
 
 #endif
 
           errorView(nullptr),
           endView(nullptr),
           osd(nullptr),
           settings(nullptr)
     {
     }
 
     int                    fileIndex;
     int                    screenSaverCookie;
 
     QTimer*                mouseMoveTimer;  ///< To hide cursor when not moved.
 
     SlideImage*            imageView;
 
 #ifdef HAVE_MEDIAPLAYER
 
     SlideVideo*            videoView;
 
 #endif
 
     SlideError*            errorView;
     SlideEnd*              endView;
     SlideOSD*              osd;
 
     SlideShowSettings*     settings;
 
     QMap<QString, QString> shortcutPrefixes;
 };
 
 SlideShowLoader::SlideShowLoader(SlideShowSettings* const settings)
     : QStackedWidget(nullptr),
       d(new Private)
 {
     d->settings = settings;
 
     setAttribute(Qt::WA_DeleteOnClose);
     setWindowFlags(Qt::FramelessWindowHint);
     setContextMenuPolicy(Qt::PreventContextMenu);
     setWindowState(windowState() | Qt::WindowFullScreen);
 
     setWindowTitle(i18n("Slideshow"));
     setObjectName(QLatin1String("Slideshow"));
     setMouseTracking(true);
 
     // ---------------------------------------------------------------
 
     d->errorView = new SlideError(this);
     d->errorView->installEventFilter(this);
 
     insertWidget(ErrorView, d->errorView);
 
     // ---------------------------------------------------------------
 
     d->imageView = new SlideImage(this);
     d->imageView->setPreviewSettings(d->settings->previewSettings);
     d->imageView->installEventFilter(this);
 
     connect(d->imageView, SIGNAL(signalImageLoaded(bool)),
             this, SLOT(slotImageLoaded(bool)));
 
     insertWidget(ImageView, d->imageView);
 
     // ---------------------------------------------------------------
 
 #ifdef HAVE_MEDIAPLAYER
 
     d->videoView = new SlideVideo(this);
     d->videoView->setInfoInterface(d->settings->iface);
     d->videoView->installEventFilter(this);
 
     connect(d->videoView, SIGNAL(signalVideoLoaded(bool)),
             this, SLOT(slotVideoLoaded(bool)));
 
     connect(d->videoView, SIGNAL(signalVideoFinished()),
             this, SLOT(slotVideoFinished()));
 
     insertWidget(VideoView, d->videoView);
 
 #endif
 
     // ---------------------------------------------------------------
 
     d->endView = new SlideEnd(this);
     d->endView->installEventFilter(this);
 
     insertWidget(EndView, d->endView);
 
     // ---------------------------------------------------------------
 
     d->osd = new SlideOSD(d->settings, this);
     d->osd->installEventFilter(this);
 
     // ---------------------------------------------------------------
 
     d->mouseMoveTimer = new QTimer(this);
     d->mouseMoveTimer->setSingleShot(true);
     d->mouseMoveTimer->setInterval(1000);
 
     connect(d->mouseMoveTimer, SIGNAL(timeout()),
             this, SLOT(slotMouseMoveTimeOut()));
 
     // ---------------------------------------------------------------
 
     QScreen* screen = qApp->primaryScreen();
 
     if (QWidget* const widget = qApp->activeWindow())
     {
         if (QWindow* const window = widget->windowHandle())
         {
             screen = window->screen();
         }
     }
 
     const int activeScreenIndex = qMax(qApp->screens().indexOf(screen), 0);
     const int preferenceScreen  = d->settings->slideScreen;
     int screenIndex             = 0;
 
     if      (preferenceScreen == -2)
     {
         screenIndex = activeScreenIndex;
     }
     else if (preferenceScreen == -1)
     {
         QScreen* const primaryScreen = qApp->primaryScreen();
         screenIndex                  = qApp->screens().indexOf(primaryScreen);
     }
     else if ((preferenceScreen >= 0) && (preferenceScreen < qApp->screens().count()))
     {
         screenIndex = preferenceScreen;
     }
     else
     {
         screenIndex              = activeScreenIndex;
         d->settings->slideScreen = -2;
         d->settings->writeToConfig();
     }
 
     slotScreenSelected(screenIndex);
 
     // ---------------------------------------------------------------
 
     inhibitScreenSaver();
     slotMouseMoveTimeOut();
     setCurrentIndex(ImageView);
 }
 
 SlideShowLoader::~SlideShowLoader()
 {
     emit signalLastItemUrl(currentItem());
 
     d->mouseMoveTimer->stop();
 
     allowScreenSaver();
 
     delete d->settings;
     delete d;
 }
 
 void SlideShowLoader::setCurrentView(SlideShowViewMode view)
 {
     switch (view)
     {
         case ErrorView:
         {
             d->osd->video(false);
             d->errorView->setCurrentUrl(currentItem());
 
             setCurrentIndex(view);
             d->osd->setCurrentUrl(currentItem());
             break;
         }
 
         case ImageView:
         {
 
 #ifdef HAVE_MEDIAPLAYER
 
             d->videoView->stop();
             d->osd->video(false);
 
 #endif
 
             setCurrentIndex(view);
             d->osd->setCurrentUrl(currentItem());
             break;
         }
 
         case VideoView:
         {
 
 #ifdef HAVE_MEDIAPLAYER
 
             d->osd->video(true);
             d->osd->pause(false);
             setCurrentIndex(view);
             d->osd->setCurrentUrl(currentItem());
 
 #endif
 
             break;
         }
 
         default : // EndView
         {
 
 #ifdef HAVE_MEDIAPLAYER
 
             d->videoView->stop();
             d->osd->video(false);
 
 #endif
 
             d->osd->pause(true);
             setCurrentIndex(view);
             break;
         }
     }
 }
 
 void SlideShowLoader::setCurrentItem(const QUrl& url)
 {
     int index = d->settings->indexOf(url);
 
     if (index != -1)
     {
         d->fileIndex = index - 1;
     }
 }
 
 QUrl SlideShowLoader::currentItem() const
 {
     return d->settings->fileList.value(d->fileIndex);
 }
 
 void SlideShowLoader::setShortCutPrefixes(const QMap<QString, QString>& prefixes)
 {
     d->shortcutPrefixes = prefixes;
 }
 
 void SlideShowLoader::slotLoadNextItem()
 {
     int num = d->settings->count();
 
     if (d->fileIndex == (num - 1))
     {
         if (d->settings->loop)
         {
             d->fileIndex = -1;
         }
     }
 
     d->fileIndex++;
 
     qCDebug(DIGIKAM_GENERAL_LOG) << "fileIndex: " << d->fileIndex;
 
     if (!d->settings->loop)
     {
         d->osd->toolBar()->setEnabledPrev(d->fileIndex > 0);
         d->osd->toolBar()->setEnabledNext(d->fileIndex < (num - 1));
     }
 
     if ((d->fileIndex >= 0) && (d->fileIndex < num))
     {
 
 #ifdef HAVE_MEDIAPLAYER
 
         QMimeDatabase mimeDB;
 
         if (mimeDB.mimeTypeForFile(currentItem().toLocalFile()).name().startsWith(QLatin1String("video/")))
         {
             d->videoView->setCurrentUrl(currentItem());
             return;
         }
 
 #endif
 
         d->imageView->setLoadUrl(currentItem());
     }
     else
     {
         endOfSlide();
     }
 }
 
 void SlideShowLoader::slotLoadPrevItem()
 {
     int num = d->settings->count();
 
     if (d->fileIndex == 0)
     {
         if (d->settings->loop)
         {
             d->fileIndex = num;
         }
     }
 
     d->fileIndex--;
 
     qCDebug(DIGIKAM_GENERAL_LOG) << "fileIndex: " << d->fileIndex;
 
     if (!d->settings->loop)
     {
         d->osd->toolBar()->setEnabledPrev(d->fileIndex > 0);
         d->osd->toolBar()->setEnabledNext(d->fileIndex < (num - 1));
     }
 
     if ((d->fileIndex >= 0) && (d->fileIndex < num))
     {
 
 #ifdef HAVE_MEDIAPLAYER
 
         QMimeDatabase mimeDB;
 
         if (mimeDB.mimeTypeForFile(currentItem().toLocalFile())
                                   .name().startsWith(QLatin1String("video/")))
         {
             d->videoView->setCurrentUrl(currentItem());
             return;
         }
 
 #endif
 
         d->imageView->setLoadUrl(currentItem());
     }
     else
     {
         endOfSlide();
     }
 }
 
 void SlideShowLoader::slotImageLoaded(bool loaded)
 {
     if (loaded)
     {
         setCurrentView(ImageView);
 
         if (d->fileIndex != -1)
         {
             if (!d->osd->isPaused())
             {
                 d->osd->pause(false);
             }
 
             preloadNextItem();
         }
     }
     else
     {
 
 #ifdef HAVE_MEDIAPLAYER
 
         // Try to load only GIF Images
 
         QMimeDatabase mimeDB;
 
         if (mimeDB.mimeTypeForFile(currentItem().toLocalFile())
                                   .name() == QLatin1String("image/gif"))
         {
             d->videoView->setCurrentUrl(currentItem());
         }
 
 #else
 
         preloadNextItem();
 
 #endif
 
     }
 
     d->osd->setLoadingReady(true);
 }
 
 void SlideShowLoader::slotVideoLoaded(bool loaded)
 {
     if (loaded)
     {
         setCurrentView(VideoView);
     }
     else
     {
         // Failed to load item
 
         setCurrentView(ErrorView);
 
         if (d->fileIndex != -1)
         {
             if (!d->osd->isPaused())
             {
                 d->osd->pause(false);
             }
         }
     }
 
     preloadNextItem();
 }
 
 void SlideShowLoader::slotVideoFinished()
 {
     if (d->fileIndex != -1)
     {
         d->osd->video(false);
         slotLoadNextItem();
     }
 }
 
 void SlideShowLoader::endOfSlide()
 {
     setCurrentView(EndView);
     d->fileIndex = -1;
     d->osd->toolBar()->setEnabledPlay(false);
     d->osd->toolBar()->setEnabledNext(false);
     d->osd->toolBar()->setEnabledPrev(false);
 }
 
 void SlideShowLoader::preloadNextItem()
 {
     int index = d->fileIndex + 1;
     int num   = d->settings->count();
 
     if (index >= num)
     {
         if (d->settings->loop)
         {
             index = 0;
         }
     }
 
     if (index < num)
     {
         QUrl nextItem = d->settings->fileList.value(index);
 
 #ifdef HAVE_MEDIAPLAYER
 
         QMimeDatabase mimeDB;
 
         if (mimeDB.mimeTypeForFile(nextItem.toLocalFile())
                                    .name().startsWith(QLatin1String("video/")))
         {
             return;
         }
 
 #endif
 
         d->imageView->setPreloadUrl(nextItem);
     }
 }
 
 void SlideShowLoader::wheelEvent(QWheelEvent* e)
 {
     d->osd->toolBar()->closeConfigurationDialog();
 
     if (e->angleDelta().y() < 0)
     {
         d->osd->pause(true);
         slotLoadNextItem();
     }
 
     if (e->angleDelta().y() > 0)
     {
         if (d->fileIndex == -1)
         {
             // EndView => backward.
 
             d->fileIndex = d->settings->count();
         }
 
         d->osd->pause(true);
         slotLoadPrevItem();
     }
 }
 
 void SlideShowLoader::mousePressEvent(QMouseEvent* e)
 {
     d->osd->toolBar()->closeConfigurationDialog();
 
-    if (d->fileIndex == -1)
+    if      (e->button() == Qt::LeftButton)
     {
-        // EndView => close Slideshow view.
+        if (d->fileIndex == -1)
+        {
+            // EndView => close Slideshow view.
 
-        close();
+            close();
 
-        return;
-    }
+            return;
+        }
 
-    if      (e->button() == Qt::LeftButton)
-    {
         d->osd->pause(true);
         slotLoadNextItem();
     }
     else if (e->button() == Qt::RightButton)
     {
         if (d->fileIndex == -1)
         {
             // EndView => backward.
 
-            d->fileIndex = d->settings->count() - 1;
+            d->fileIndex = d->settings->count();
         }
 
         d->osd->pause(true);
         slotLoadPrevItem();
     }
 }
 
 void SlideShowLoader::keyPressEvent(QKeyEvent* e)
 {
     if (!e)
     {
         return;
     }
 
     if (e->key() == Qt::Key_F4)
     {
         d->osd->toggleProperties();
         return;
     }
 
     d->osd->toolBar()->keyPressEvent(e);
 }
 
 bool SlideShowLoader::eventFilter(QObject* obj, QEvent* ev)
 {
     if (ev->type() == QEvent::MouseMove)
     {
         setCursor(QCursor(Qt::ArrowCursor));
 
 #ifdef HAVE_MEDIAPLAYER
 
         d->videoView->showIndicator(true);
 
 #endif
 
         d->mouseMoveTimer->start();
         return false;
     }
 
     // pass the event on to the parent class
 
     return QWidget::eventFilter(obj, ev);
 }
 
 void SlideShowLoader::slotMouseMoveTimeOut()
 {
     if (!d->osd->isUnderMouse())
     {
         setCursor(QCursor(Qt::BlankCursor));
     }
 
 #ifdef HAVE_MEDIAPLAYER
 
     d->videoView->showIndicator(false);
 
 #endif
 
 }
 
 /**
  * Inspired from Okular's presentation widget
  * TODO: Add OSX and Windows support
  */
 void SlideShowLoader::inhibitScreenSaver()
 {
 
 #ifdef HAVE_DBUS
 
     QDBusMessage message = QDBusMessage::createMethodCall(QLatin1String("org.freedesktop.ScreenSaver"),
                                                           QLatin1String("/ScreenSaver"),
                                                           QLatin1String("org.freedesktop.ScreenSaver"),
                                                           QLatin1String("Inhibit"));
     message << QLatin1String("digiKam");
     message << i18nc("Reason for inhibiting the screensaver activation, when the presentation mode is active", "Giving a slideshow");
 
     QDBusReply<uint> reply = QDBusConnection::sessionBus().call(message);
 
     if (reply.isValid())
     {
         d->screenSaverCookie = reply.value();
     }
 
 #endif
 
 }
 
 void SlideShowLoader::allowScreenSaver()
 {
 
 #ifdef HAVE_DBUS
 
     if (d->screenSaverCookie != -1)
     {
         QDBusMessage message = QDBusMessage::createMethodCall(QLatin1String("org.freedesktop.ScreenSaver"),
                                                               QLatin1String("/ScreenSaver"),
                                                               QLatin1String("org.freedesktop.ScreenSaver"),
                                                               QLatin1String("UnInhibit"));
         message << (uint)d->screenSaverCookie;
         QDBusConnection::sessionBus().send(message);
     }
 
 #endif
 
 }
 
 void SlideShowLoader::slotAssignRating(int rating)
 {
     DInfoInterface::DInfoMap info;
     info.insert(QLatin1String("rating"), rating);
 
     d->settings->iface->setItemInfo(currentItem(), info);
 
     dispatchCurrentInfoChange(currentItem());
 }
 
 void SlideShowLoader::slotAssignColorLabel(int color)
 {
     DInfoInterface::DInfoMap info;
     info.insert(QLatin1String("colorlabel"), color);
 
     d->settings->iface->setItemInfo(currentItem(), info);
 
     dispatchCurrentInfoChange(currentItem());
 }
 
 void SlideShowLoader::slotAssignPickLabel(int pick)
 {
     DInfoInterface::DInfoMap info;
     info.insert(QLatin1String("picklabel"), pick);
 
     d->settings->iface->setItemInfo(currentItem(), info);
 
     dispatchCurrentInfoChange(currentItem());
 }
 
 void SlideShowLoader::slotToggleTag(int tag)
 {
     DInfoInterface::DInfoMap info;
     info.insert(QLatin1String("tag"), tag);
 
     d->settings->iface->setItemInfo(currentItem(), info);
 
     dispatchCurrentInfoChange(currentItem());
 }
 
 void SlideShowLoader::slotHandleShortcut(const QString& shortcut, int val)
 {
     //qCDebug(DIGIKAM_GENERAL_LOG) << "SlideShowLoader::slotHandleShortcut";
 
     if (d->shortcutPrefixes.contains(QLatin1String("rating")) &&
         shortcut.startsWith(d->shortcutPrefixes[QLatin1String("rating")]))
     {
         slotAssignRating(val);
 
         return;
     }
 
     if (d->shortcutPrefixes.contains(QLatin1String("colorlabel")) &&
         shortcut.startsWith(d->shortcutPrefixes[QLatin1String("colorlabel")]))
     {
         slotAssignColorLabel(val);
 
         return;
     }
 
     if (d->shortcutPrefixes.contains(QLatin1String("picklabel")) &&
         shortcut.startsWith(d->shortcutPrefixes[QLatin1String("picklabel")]))
     {
         slotAssignPickLabel(val);
 
         return;
     }
 
     if (d->shortcutPrefixes.contains(QLatin1String("tag")) &&
         shortcut.startsWith(d->shortcutPrefixes[QLatin1String("tag")]))
     {
         slotToggleTag(val);
 
         return;
     }
 
     qCWarning(DIGIKAM_GENERAL_LOG) << "Shortcut is not yet supported in SlideShowLoader::slotHandleShortcut():" << shortcut;
 }
 
 void SlideShowLoader::dispatchCurrentInfoChange(const QUrl& url)
 {
     if (currentItem() == url)
     {
         d->osd->setCurrentUrl(currentItem());
     }
 }
 
 void SlideShowLoader::slotPause()
 {
 
 #ifdef HAVE_MEDIAPLAYER
 
     if (currentIndex() == VideoView)
     {
         d->videoView->pause(true);
     }
     else
 
 #endif
 
     {
         d->osd->pause(true);
     }
 }
 
 void SlideShowLoader::slotPlay()
 {
     d->settings->suffleImages();
 
 #ifdef HAVE_MEDIAPLAYER
 
     if (currentIndex() == VideoView)
     {
         d->videoView->pause(false);
     }
     else
 
 #endif
 
     {
         d->osd->pause(false);
     }
 }
 
 void SlideShowLoader::slotScreenSelected(int screen)
 {
     if (screen >= qApp->screens().count())
     {
         return;
     }
 
     QRect deskRect = qApp->screens().at(screen)->geometry();
 
     setWindowState(windowState() & ~Qt::WindowFullScreen);
 
     move(deskRect.x(), deskRect.y());
     resize(deskRect.width(), deskRect.height());
 
     setWindowState(windowState() | Qt::WindowFullScreen);
 
     // update OSD position
 
     if (d->fileIndex != -1)
     {
         qApp->processEvents();
         d->osd->setCurrentUrl(currentItem());
     }
 
     qCDebug(DIGIKAM_GENERAL_LOG) << "Slideshow: move to screen: " << screen
                                  << " :: " << deskRect;
 }
 
 } // namespace DigikamGenericSlideShowPlugin
diff --git a/core/libs/database/utils/ifaces/dio.cpp b/core/libs/database/utils/ifaces/dio.cpp
index 0419403a3b..2dd0b1ada5 100644
--- a/core/libs/database/utils/ifaces/dio.cpp
+++ b/core/libs/database/utils/ifaces/dio.cpp
@@ -1,642 +1,642 @@
 /* ============================================================
  *
  * This file is a part of digiKam project
  * https://www.digikam.org
  *
  * Date        : 2005-05-17
  * Description : low level files management interface.
  *
  * Copyright (C) 2005      by Renchi Raju <renchi dot raju at gmail dot com>
  * Copyright (C) 2012-2013 by Marcel Wiesweg <marcel dot wiesweg at gmx dot de>
  * Copyright (C) 2015      by Mohamed_Anwer <m_dot_anwer at gmx dot com>
  * Copyright (C) 2018      by Maik Qualmann <metzpinguin at gmail dot 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, 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.
  *
  * ============================================================ */
 
 #include "dio.h"
 
 // Qt includes
 
 #include <QFileInfo>
 
 // KDE includes
 
 #include <klocalizedstring.h>
 
 // Local includes
 
 #include "digikam_debug.h"
 #include "iteminfo.h"
 #include "diofinders.h"
 #include "albummanager.h"
 #include "tagscache.h"
 #include "coredb.h"
 #include "coredbaccess.h"
 #include "album.h"
 #include "dmetadata.h"
 #include "metaenginesettings.h"
 #include "scancontroller.h"
 #include "thumbsdb.h"
 #include "thumbsdbaccess.h"
 #include "iojobsmanager.h"
 #include "collectionmanager.h"
 #include "dnotificationwrapper.h"
 #include "loadingcacheinterface.h"
 #include "progressmanager.h"
 #include "digikamapp.h"
 #include "iojobdata.h"
 
 namespace Digikam
 {
 
 class Q_DECL_HIDDEN DIOCreator
 {
 public:
 
     DIO object;
 };
 
 Q_GLOBAL_STATIC(DIOCreator, creator)
 
 // ------------------------------------------------------------------------------------------------
 
 DIO* DIO::instance()
 {
     return &creator->object;
 }
 
 DIO::DIO()
 {
     m_processingCount = 0;
 }
 
 DIO::~DIO()
 {
 }
 
 void DIO::cleanUp()
 {
 }
 
 bool DIO::itemsUnderProcessing()
 {
     return instance()->m_processingCount;
 }
 
 // Album -> Album -----------------------------------------------------
 
 void DIO::copy(PAlbum* const src, PAlbum* const dest)
 {
     if (!src || !dest)
     {
         return;
     }
 
     instance()->processJob(new IOJobData(IOJobData::CopyAlbum, src, dest));
 }
 
 void DIO::move(PAlbum* const src, PAlbum* const dest)
 {
     if (!src || !dest)
     {
         return;
     }
 
 #ifdef Q_OS_WIN
     AlbumManager::instance()->removeWatchedPAlbums(src);
 #endif
 
     instance()->processJob(new IOJobData(IOJobData::MoveAlbum, src, dest));
 }
 
 // Images -> Album ----------------------------------------------------
 
 void DIO::copy(const QList<ItemInfo>& infos, PAlbum* const dest)
 {
     if (!dest)
     {
         return;
     }
 
     instance()->processJob(new IOJobData(IOJobData::CopyImage, infos, dest));
 }
 
 void DIO::move(const QList<ItemInfo>& infos, PAlbum* const dest)
 {
     if (!dest)
     {
         return;
     }
 
     instance()->processJob(new IOJobData(IOJobData::MoveImage, infos, dest));
 }
 
 // External files -> album --------------------------------------------
 
 void DIO::copy(const QUrl& src, PAlbum* const dest)
 {
     copy(QList<QUrl>() << src, dest);
 }
 
 void DIO::copy(const QList<QUrl>& srcList, PAlbum* const dest)
 {
     if (!dest)
     {
         return;
     }
 
     instance()->processJob(new IOJobData(IOJobData::CopyFiles, srcList, dest));
 }
 
 void DIO::move(const QUrl& src, PAlbum* const dest)
 {
     move(QList<QUrl>() << src, dest);
 }
 
 void DIO::move(const QList<QUrl>& srcList, PAlbum* const dest)
 {
     if (!dest)
     {
         return;
     }
 
     instance()->processJob(new IOJobData(IOJobData::MoveFiles, srcList, dest));
 }
 
 // Rename --------------------------------------------------------------
 
 void DIO::rename(const QUrl& src, const QString& newName, bool overwrite)
 {
     if (src.isEmpty() || newName.isEmpty())
     {
         return;
     }
 
     ItemInfo info = ItemInfo::fromUrl(src);
 
     instance()->processJob(new IOJobData(IOJobData::Rename, info, newName, overwrite));
 }
 
 // Delete --------------------------------------------------------------
 
 void DIO::del(const QList<ItemInfo>& infos, bool useTrash)
 {
     instance()->processJob(new IOJobData(useTrash ? IOJobData::Trash
                                                   : IOJobData::Delete, infos));
 }
 
 void DIO::del(const ItemInfo& info, bool useTrash)
 {
     del(QList<ItemInfo>() << info, useTrash);
 }
 
 void DIO::del(PAlbum* const album, bool useTrash)
 {
     if (!album)
     {
         return;
     }
 
 #ifdef Q_OS_WIN
     AlbumManager::instance()->removeWatchedPAlbums(album);
 #endif
 
     instance()->createJob(new IOJobData(useTrash ? IOJobData::Trash
                                                  : IOJobData::Delete, album));
 }
 
 // Restore Trash -------------------------------------------------------
 
 void DIO::restoreTrash(const DTrashItemInfoList& infos)
 {
     instance()->createJob(new IOJobData(IOJobData::Restore, infos));
 }
 
 // Empty Trash ---------------------------------------------------------
 
 void DIO::emptyTrash(const DTrashItemInfoList& infos)
 {
     instance()->createJob(new IOJobData(IOJobData::Empty, infos));
 }
 
 // ------------------------------------------------------------------------------------------------
 
 void DIO::processJob(IOJobData* const data)
 {
     const int operation = data->operation();
 
     if (operation == IOJobData::CopyImage || operation == IOJobData::MoveImage)
     {
         // this is a fast db operation, do here
         GroupedImagesFinder finder(data->itemInfos());
         data->setItemInfos(finder.infos);
 
         QStringList      filenames;
         QList<qlonglong> ids;
 
         foreach (const ItemInfo& info, data->itemInfos())
         {
             filenames << info.name();
             ids << info.id();
         }
 
         ScanController::instance()->hintAtMoveOrCopyOfItems(ids, data->destAlbum(), filenames);
     }
     else if (operation == IOJobData::CopyAlbum || operation == IOJobData::MoveAlbum)
     {
         ScanController::instance()->hintAtMoveOrCopyOfAlbum(data->srcAlbum(), data->destAlbum());
         createJob(data);
         return;
     }
     else if (operation == IOJobData::Delete || operation == IOJobData::Trash)
     {
         qCDebug(DIGIKAM_DATABASE_LOG) << "Number of files to be deleted:" << data->sourceUrls().count();
     }
 
     SidecarFinder finder(data->sourceUrls());
     data->setSourceUrls(finder.localFiles);
 
     if (operation == IOJobData::Rename)
     {
         if (!data->itemInfos().isEmpty())
         {
             ItemInfo info      = data->itemInfos().first();
             PAlbum* const album = AlbumManager::instance()->findPAlbum(info.albumId());
 
             if (album)
             {
                 ScanController::instance()->hintAtMoveOrCopyOfItem(info.id(), album,
                                                                    data->destUrl().fileName());
             }
 
             for (int i = 0 ; i < finder.localFiles.length() ; ++i)
             {
                 if (finder.localFileModes.at(i))
                 {
                     data->setDestUrl(finder.localFiles.at(i),
                                      QUrl::fromLocalFile(data->destUrl().toLocalFile() +
                                                          finder.localFileSuffixes.at(i)));
                 }
                 else
                 {
-                    QFileInfo info(data->destUrl().toLocalFile());
+                    QFileInfo basInfo(data->destUrl().toLocalFile());
 
                     data->setDestUrl(finder.localFiles.at(i),
-                                     QUrl::fromLocalFile(info.path()             +
-                                                         QLatin1Char('/')        +
-                                                         info.completeBaseName() +
+                                     QUrl::fromLocalFile(basInfo.path()             +
+                                                         QLatin1Char('/')           +
+                                                         basInfo.completeBaseName() +
                                                          finder.localFileSuffixes.at(i)));
                 }
             }
         }
     }
 
     createJob(data);
 }
 
 void DIO::createJob(IOJobData* const data)
 {
     if (data->sourceUrls().isEmpty())
     {
         delete data;
         return;
     }
 
     ProgressItem* item = nullptr;
     QString itemString = getItemString(data);
 
     if (!itemString.isEmpty())
     {
         item = ProgressManager::instance()->createProgressItem(itemString,
                                                                QString(), true, false);
         item->setTotalItems(data->sourceUrls().count());
         data->setProgressId(item->id());
     }
 
     IOJobsThread* const jobThread = IOJobsManager::instance()->startIOJobs(data);
 
     connect(jobThread, SIGNAL(signalOneProccessed(QUrl)),
             this, SLOT(slotOneProccessed(QUrl)));
 
     connect(jobThread, SIGNAL(finished()),
             this, SLOT(slotResult()));
 
     if (data->operation() == IOJobData::Rename)
     {
         connect(jobThread, SIGNAL(signalRenameFailed(QUrl)),
                 this, SIGNAL(signalRenameFailed(QUrl)));
 
         connect(jobThread, SIGNAL(finished()),
                 this, SIGNAL(signalRenameFinished()));
     }
 
     if (data->operation() == IOJobData::Empty ||
         data->operation() == IOJobData::Restore)
     {
         connect(jobThread, SIGNAL(finished()),
                 this, SIGNAL(signalTrashFinished()));
     }
 
     if (item)
     {
         connect(item, SIGNAL(progressItemCanceled(ProgressItem*)),
                 jobThread, SLOT(slotCancel()));
 
         connect(item, SIGNAL(progressItemCanceled(ProgressItem*)),
                 this, SLOT(slotCancel(ProgressItem*)));
     }
 
     ++m_processingCount;
 }
 
 void DIO::slotResult()
 {
     IOJobsThread* const jobThread = dynamic_cast<IOJobsThread*>(sender());
 
     if (!jobThread || !jobThread->jobData())
     {
         return;
     }
 
     IOJobData* const data = jobThread->jobData();
 
     if (jobThread->hasErrors() && data->operation() != IOJobData::Rename)
     {
         // Pop-up a message about the error.
         QString errors = jobThread->errorsList().join(QLatin1Char('\n'));
         DNotificationWrapper(QString(), errors, DigikamApp::instance(),
                              DigikamApp::instance()->windowTitle());
     }
 
     if (m_processingCount)
     {
         --m_processingCount;
     }
 
     slotCancel(getProgressItem(data));
 }
 
 void DIO::slotOneProccessed(const QUrl& url)
 {
     IOJobsThread* const jobThread = dynamic_cast<IOJobsThread*>(sender());
 
     if (!jobThread || !jobThread->jobData())
     {
         return;
     }
 
     IOJobData* const data = jobThread->jobData();
     const int operation   = data->operation();
 
     if (operation == IOJobData::MoveImage)
     {
         ItemInfo info = data->findItemInfo(url);
 
         if (!info.isNull() && data->destAlbum())
         {
             CoreDbAccess().db()->moveItem(info.albumId(), info.name(),
                                           data->destAlbum()->id(), info.name());
         }
     }
     else if (operation == IOJobData::Delete)
     {
         // Mark the images as obsolete and remove them
         // from their album and from the grouped
         PAlbum* const album = data->srcAlbum();
 
         if (album && album->fileUrl() == url)
         {
             // get all deleted albums
             CoreDbAccess access;
             QList<int> albumsToDelete;
             QList<qlonglong> imagesToRemove;
 
             addAlbumChildrenToList(albumsToDelete, album);
 
             foreach (int albumId, albumsToDelete)
             {
                 imagesToRemove << access.db()->getItemIDsInAlbum(albumId);
             }
 
             foreach (const qlonglong& imageId, imagesToRemove)
             {
                 access.db()->removeAllImageRelationsFrom(imageId,
                                                          DatabaseRelation::Grouped);
             }
 
             access.db()->removeItemsPermanently(imagesToRemove, albumsToDelete);
         }
         else
         {
             ItemInfo info = data->findItemInfo(url);
 
             if (!info.isNull())
             {
                 int originalVersionTag    = TagsCache::instance()->getOrCreateInternalTag(InternalTagName::originalVersion());
                 int needTaggingTag        = TagsCache::instance()->getOrCreateInternalTag(InternalTagName::needTaggingHistoryGraph());
                 QList<qlonglong> imageIds = CoreDbAccess().db()->getImagesRelatedFrom(info.id(), DatabaseRelation::DerivedFrom);
 
                 CoreDbAccess access;
 
                 foreach (const qlonglong& id, imageIds)
                 {
                     access.db()->removeItemTag(id, originalVersionTag);
                     access.db()->addItemTag(id, needTaggingTag);
                 }
 
                 access.db()->removeAllImageRelationsFrom(info.id(),
                                                          DatabaseRelation::Grouped);
 
                 access.db()->removeItemsPermanently(QList<qlonglong>() << info.id(),
                                                     QList<int>() << info.albumId());
             }
         }
     }
     else if (operation == IOJobData::Trash)
     {
         ItemInfo info = data->findItemInfo(url);
 
         if (!info.isNull())
         {
             int originalVersionTag    = TagsCache::instance()->getOrCreateInternalTag(InternalTagName::originalVersion());
             int needTaggingTag        = TagsCache::instance()->getOrCreateInternalTag(InternalTagName::needTaggingHistoryGraph());
             QList<qlonglong> imageIds = CoreDbAccess().db()->getImagesRelatedFrom(info.id(), DatabaseRelation::DerivedFrom);
 
             CoreDbAccess access;
 
             foreach (const qlonglong& id, imageIds)
             {
                 access.db()->removeItemTag(id, originalVersionTag);
                 access.db()->addItemTag(id, needTaggingTag);
             }
 
             access.db()->removeItems(QList<qlonglong>() << info.id(),
                                      QList<int>() << info.albumId());
         }
     }
     else if (operation == IOJobData::Rename)
     {
         ItemInfo info = data->findItemInfo(url);
 
         if (!info.isNull())
         {
             QString oldPath = url.toLocalFile();
             QString newName = data->destUrl(url).fileName();
             QString newPath = data->destUrl(url).toLocalFile();
 
             if (data->overwrite())
             {
                 ThumbsDbAccess().db()->removeByFilePath(newPath);
                 LoadingCacheInterface::fileChanged(newPath, false);
                 CoreDbAccess().db()->deleteItem(info.albumId(), newName);
             }
 
             ThumbsDbAccess().db()->renameByFilePath(oldPath, newPath);
             // Remove old thumbnails and images from the cache
             LoadingCacheInterface::fileChanged(oldPath, false);
             // Rename in ItemInfo and database
             info.setName(newName);
         }
     }
 
     // Scan folders for changes
 
     if (operation == IOJobData::Delete || operation == IOJobData::Trash ||
         operation == IOJobData::MoveAlbum)
     {
         PAlbum* const album = data->srcAlbum();
         QString scanPath;
 
         if (album)
         {
             PAlbum* const parent = dynamic_cast<PAlbum*>(album->parent());
 
             if (parent)
             {
                 scanPath = parent->fileUrl().toLocalFile();
             }
         }
 
         if (scanPath.isEmpty())
         {
             scanPath = url.adjusted(QUrl::RemoveFilename).toLocalFile();
         }
 
         ScanController::instance()->scheduleCollectionScanRelaxed(scanPath);
     }
 
     if (operation == IOJobData::CopyImage || operation == IOJobData::CopyAlbum ||
         operation == IOJobData::CopyFiles || operation == IOJobData::MoveImage ||
         operation == IOJobData::MoveAlbum || operation == IOJobData::MoveFiles)
     {
         QString scanPath = data->destUrl().toLocalFile();
         ScanController::instance()->scheduleCollectionScanRelaxed(scanPath);
     }
 
     if (operation == IOJobData::Restore)
     {
         QString scanPath = url.adjusted(QUrl::RemoveFilename).toLocalFile();
         ScanController::instance()->scheduleCollectionScanRelaxed(scanPath);
     }
 
     ProgressItem* const item = getProgressItem(data);
 
     if (item)
     {
         item->advance(1);
     }
 }
 
 QString DIO::getItemString(IOJobData* const data) const
 {
     switch (data->operation())
     {
         case IOJobData::CopyAlbum:
             return i18n("Copy Album");
 
         case IOJobData::CopyImage:
             return i18n("Copy Images");
 
         case IOJobData::CopyFiles:
             return i18n("Copy Files");
 
         case IOJobData::MoveAlbum:
             return i18n("Move Album");
 
         case IOJobData::MoveImage:
             return i18n("Move Images");
 
         case IOJobData::MoveFiles:
             return i18n("Move Files");
 
         case IOJobData::Delete:
             return i18n("Delete");
 
         case IOJobData::Trash:
             return i18n("Trash");
 
         case IOJobData::Restore:
             return i18n("Restore Trash");
 
         case IOJobData::Empty:
             return i18n("Empty Trash");
 
         default:
             break;
     }
 
     return QString();
 }
 
 ProgressItem* DIO::getProgressItem(IOJobData* const data) const
 {
     QString itemId = data->getProgressId();
 
     if (itemId.isEmpty())
     {
         return nullptr;
     }
 
     return ProgressManager::instance()->findItembyId(itemId);
 }
 
 void DIO::slotCancel(ProgressItem* item)
 {
     if (item)
     {
         item->setComplete();
     }
 }
 
 void DIO::addAlbumChildrenToList(QList<int>& list, Album* const album)
 {
     // simple recursive helper function
     if (album)
     {
         if (!list.contains(album->id()))
         {
             list.append(album->id());
         }
 
         AlbumIterator it(album);
 
         while (it.current())
         {
             addAlbumChildrenToList(list, *it);
             ++it;
         }
     }
 }
 
 } // namespace Digikam
diff --git a/core/libs/database/utils/widgets/dbsettingswidget.cpp b/core/libs/database/utils/widgets/dbsettingswidget.cpp
index 984a7f52f1..6d652d3927 100644
--- a/core/libs/database/utils/widgets/dbsettingswidget.cpp
+++ b/core/libs/database/utils/widgets/dbsettingswidget.cpp
@@ -1,855 +1,860 @@
 /* ============================================================
  *
  * This file is a part of digiKam project
  * https://www.digikam.org
  *
  * Date        : 2009-11-14
  * Description : database settings widget
  *
  * Copyright (C) 2009-2010 by Holger Foerster <Hamsi2k at freenet dot de>
  * Copyright (C) 2010-2020 by Gilles Caulier <caulier dot gilles at gmail dot 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, 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.
  *
  * ============================================================ */
 
 #include "dbsettingswidget_p.h"
 
 namespace Digikam
 {
 
 DatabaseSettingsWidget::DatabaseSettingsWidget(QWidget* const parent)
     : QWidget(parent),
       d(new Private)
 {
     setupMainArea();
 }
 
 DatabaseSettingsWidget::~DatabaseSettingsWidget()
 {
     delete d;
 }
 
 void DatabaseSettingsWidget::setupMainArea()
 {
     QVBoxLayout* const layout = new QVBoxLayout();
     setLayout(layout);
 
     // --------------------------------------------------------
 
     const int spacing = QApplication::style()->pixelMetric(QStyle::PM_DefaultLayoutSpacing);
 
     QGroupBox* const dbConfigBox    = new QGroupBox(i18n("Database Configuration"), this);
     QVBoxLayout* const vlay         = new QVBoxLayout(dbConfigBox);
 
     DHBox* const typeHbox           = new DHBox();
     QLabel* const databaseTypeLabel = new QLabel(typeHbox);
     d->dbType                       = new QComboBox(typeHbox);
     databaseTypeLabel->setText(i18n("Type:"));
 
     // --------- fill with default values ---------------------
 
     int dbTypeIdx               = 0;
     d->dbType->addItem(i18n("SQLite"),                        SQlite);
     d->dbTypeMap[SQlite]        = dbTypeIdx++;
 
 #ifdef HAVE_MYSQLSUPPORT
 
 #   ifdef HAVE_INTERNALMYSQL
     d->dbType->addItem(i18n("Mysql Internal (experimental)"), MysqlInternal);
     d->dbTypeMap[MysqlInternal] = dbTypeIdx++;
 #   endif
 
     d->dbType->addItem(i18n("MySQL Server (experimental)"),   MysqlServer);
     d->dbTypeMap[MysqlServer]   = dbTypeIdx++;
 #endif
 
     QString tip = i18n("<p>Select here the type of database backend.</p>"
                        "<p><b>SQlite</b> backend is for local database storage with a small or medium collection sizes. "
                        "It is the default and recommended backend for collections with less than 100K items.</p>");
 
 
 #ifdef HAVE_MYSQLSUPPORT
 
 #   ifdef HAVE_INTERNALMYSQL
     tip.append(i18n("<p><b>MySQL Internal</b> backend is for local database storage with huge collection sizes. "
                     "This backend is recommend for local collections with more than 100K items.</p>"
                     "<p><i>Be careful: this one still in experimental stage.</i></p>"));
 #   endif
 
     tip.append(i18n("<p><b>MySQL Server</b> backend is a more robust solution especially for remote and shared database storage. "
                     "It is also more efficient to manage huge collection sizes with more than 100K items.</p>"
                     "<p><i>Be careful: this one still in experimental stage.</i></p>"));
 #endif
 
     d->dbType->setToolTip(tip);
 
     // --------------------------------------------------------
 
     d->dbPathLabel = new QLabel(i18n("<p>Set here the location where the database files will be stored on your system. "
                                      "There are three databases: one for all collections properties, "
                                      "one to store compressed thumbnails, "
                                      "and one to store faces recognition metadata.<br/>"
                                      "Write access is required to be able to edit image properties.</p>"
                                      "<p>Databases are digiKam core engines. Take care to use a place hosted by fast "
                                      "hardware (as SSD) with enough free space especially for thumbnails database.</p>"
                                      "<p>Note: a remote file system such as NFS, cannot be used here. "
                                      "For performance reasons, it is also recommended not to use removable media.</p>"
                                      "<p></p>"), dbConfigBox);
     d->dbPathLabel->setWordWrap(true);
     d->dbPathEdit  = new DFileSelector(dbConfigBox);
     d->dbPathEdit->setFileDlgMode(QFileDialog::Directory);
 
     // --------------------------------------------------------
 
     d->mysqlCmdBox = new DVBox(dbConfigBox);
     d->mysqlCmdBox->layout()->setContentsMargins(0, 0, 0, 0);
 
     new DLineWidget(Qt::Horizontal, d->mysqlCmdBox);
     QLabel* const mysqlBinariesLabel  = new QLabel(i18n("<p>Here you can configure locations where MySQL binary tools are located. "
                                                         "digiKam will try to find these binaries automatically if they are "
                                                         "already installed on your computer.</p>"),
                                                    d->mysqlCmdBox);
     mysqlBinariesLabel->setWordWrap(true);
 
     QGroupBox* const binaryBox        = new QGroupBox(d->mysqlCmdBox);
     QGridLayout* const binaryLayout   = new QGridLayout;
     binaryBox->setLayout(binaryLayout);
     binaryBox->setTitle(i18nc("@title:group", "MySQL Binaries"));
     d->dbBinariesWidget = new DBinarySearch(binaryBox);
     d->dbBinariesWidget->header()->setSectionHidden(2, true);
 
     d->dbBinariesWidget->addBinary(d->mysqlInitBin);
     d->dbBinariesWidget->addBinary(d->mysqlServBin);
 
 #ifdef Q_OS_LINUX
     d->dbBinariesWidget->addDirectory(QLatin1String("/usr/bin"));
     d->dbBinariesWidget->addDirectory(QLatin1String("/usr/sbin"));
 #endif
 
 #ifdef Q_OS_OSX
     // Std Macports install
     d->dbBinariesWidget->addDirectory(QLatin1String("/opt/local/bin"));
     d->dbBinariesWidget->addDirectory(QLatin1String("/opt/local/sbin"));
     d->dbBinariesWidget->addDirectory(QLatin1String("/opt/local/lib/mariadb/bin"));
 
     // digiKam Bundle PKG install
     d->dbBinariesWidget->addDirectory(QLatin1String("/opt/digikam/bin"));
     d->dbBinariesWidget->addDirectory(QLatin1String("/opt/digikam/sbin"));
     d->dbBinariesWidget->addDirectory(QLatin1String("/opt/digikam/lib/mariadb/bin"));
 #endif
 
 #ifdef Q_OS_WIN
     d->dbBinariesWidget->addDirectory(QLatin1String("C:/Program Files/MariaDB 10.3/bin"));
     d->dbBinariesWidget->addDirectory(QLatin1String("C:/Program Files (x86/MariaDB 10.3/bin"));
 #endif
 
     d->dbBinariesWidget->allBinariesFound();
 
     // --------------------------------------------------------
 
     d->tab = new QTabWidget(this);
 
     QLabel* const hostNameLabel                      = new QLabel(i18n("Host Name:"));
     d->hostName                                      = new QLineEdit();
     d->hostName->setPlaceholderText(i18n("Set the host computer name"));
     d->hostName->setToolTip(i18n("This is the computer name running MySQL server.\nThis can be \"localhost\" for a local server, "
                                  "or the network computer\n name (or IP address) in case of remote computer."));
 
     QLabel* const connectOptsLabel                   = new QLabel(i18n("<a href=\"http://doc.qt.io/qt-5/"
                                                                        "qsqldatabase.html#setConnectOptions\">Connect options:</a>"));
     connectOptsLabel->setOpenExternalLinks(true);
     d->connectOpts                                   = new QLineEdit();
     d->connectOpts->setPlaceholderText(i18n("Set the database connection options"));
     d->connectOpts->setToolTip(i18n("Set the MySQL server connection options.\nFor advanced users only."));
 
     QLabel* const userNameLabel                      = new QLabel(i18n("User:"));
     d->userName                                      = new QLineEdit();
     d->userName->setPlaceholderText(i18n("Set the database account name"));
     d->userName->setToolTip(i18n("Set the MySQL server account name used\nby digiKam to be connected to the server.\n"
                                  "This account must be available on the remote MySQL server when database have been created."));
 
     QLabel* const passwordLabel                      = new QLabel(i18n("Password:"));
     d->password                                      = new QLineEdit();
     d->password->setToolTip(i18n("Set the MySQL server account password used\nby digiKam to be connected to the server.\n"
                                  "You can left this field empty to use an account set without password."));
     d->password->setEchoMode(QLineEdit::Password);
 
     DHBox* const phbox                               = new DHBox();
     QLabel* const hostPortLabel                      = new QLabel(i18n("Host Port:"));
     d->hostPort                                      = new QSpinBox(phbox);
     d->hostPort->setToolTip(i18n("Set the host computer port.\nUsually, MySQL server use port number 3306 by default"));
     d->hostPort->setMaximum(65535);
     d->hostPort->setValue(3306);
     QWidget* const space                             = new QWidget(phbox);
     phbox->setStretchFactor(space, 10);
     QPushButton* const checkDBConnectBtn             = new QPushButton(i18n("Check Connection"), phbox);
     checkDBConnectBtn->setToolTip(i18n("Run a basic database connection to see if current MySQL server settings is suitable."));
 
     // Only accept printable Ascii char for database names.
     QRegExp asciiRx(QLatin1String("[\x20-\x7F]+$"));
     QValidator* const asciiValidator = new QRegExpValidator(asciiRx, this);
 
     QLabel* const dbNameCoreLabel                    = new QLabel(i18n("Core Db Name:"));
     d->dbNameCore                                    = new QLineEdit();
     d->dbNameCore->setPlaceholderText(i18n("Set the core database name"));
     d->dbNameCore->setToolTip(i18n("The core database is lead digiKam container used to store\nalbums, items, and searches metadata."));
     d->dbNameCore->setValidator(asciiValidator);
 
     QLabel* const dbNameThumbsLabel                  = new QLabel(i18n("Thumbs Db Name:"));
     d->dbNameThumbs                                  = new QLineEdit();
     d->dbNameThumbs->setPlaceholderText(i18n("Set the thumbnails database name"));
     d->dbNameThumbs->setToolTip(i18n("The thumbnails database is used by digiKam to host\nimage thumbs with wavelets compression images.\n"
                                      "This one can use quickly a lots of space,\nespecially if you have huge collections."));
     d->dbNameThumbs->setValidator(asciiValidator);
 
     QLabel* const dbNameFaceLabel                    = new QLabel(i18n("Face Db Name:"));
     d->dbNameFace                                    = new QLineEdit();
     d->dbNameFace->setPlaceholderText(i18n("Set the face database name"));
     d->dbNameFace->setToolTip(i18n("The face database is used by digiKam to host image histograms\ndedicated to faces recognition process.\n"
                                    "This one can use quickly a lots of space, especially\nif you a lots of image with people faces detected "
                                    "and tagged."));
     d->dbNameFace->setValidator(asciiValidator);
 
     QLabel* const dbNameSimilarityLabel              = new QLabel(i18n("Similarity Db Name:"));
     d->dbNameSimilarity                              = new QLineEdit();
     d->dbNameSimilarity->setPlaceholderText(i18n("Set the similarity database name"));
     d->dbNameSimilarity->setToolTip(i18n("The similarity database is used by digiKam to host image Haar matrix data for the similarity search."));
     d->dbNameSimilarity->setValidator(asciiValidator);
 
     QPushButton* const defaultValuesBtn              = new QPushButton(i18n("Default Settings"));
     defaultValuesBtn->setToolTip(i18n("Reset database names settings to common default values."));
 
     d->expertSettings                                = new QGroupBox();
     d->expertSettings->setFlat(true);
     QFormLayout* const expertSettinglayout           = new QFormLayout();
     d->expertSettings->setLayout(expertSettinglayout);
 
     expertSettinglayout->addRow(hostNameLabel,         d->hostName);
     expertSettinglayout->addRow(userNameLabel,         d->userName);
     expertSettinglayout->addRow(passwordLabel,         d->password);
     expertSettinglayout->addRow(connectOptsLabel,      d->connectOpts);
     expertSettinglayout->addRow(hostPortLabel,         phbox);
     expertSettinglayout->addRow(new DLineWidget(Qt::Horizontal, d->expertSettings));
     expertSettinglayout->addRow(dbNameCoreLabel,       d->dbNameCore);
     expertSettinglayout->addRow(dbNameThumbsLabel,     d->dbNameThumbs);
     expertSettinglayout->addRow(dbNameFaceLabel,       d->dbNameFace);
     expertSettinglayout->addRow(dbNameSimilarityLabel, d->dbNameSimilarity);
     expertSettinglayout->addRow(new QWidget(),         defaultValuesBtn);
 
     d->tab->addTab(d->expertSettings, i18n("Remote Server Settings"));
 
     // --------------------------------------------------------
 
     d->dbNoticeBox           = new QGroupBox(i18n("Database Server Instructions"), this);
     QVBoxLayout* const vlay2 = new QVBoxLayout(d->dbNoticeBox);
     QLabel* const notice     = new QLabel(i18n("<p>digiKam expects that database is already created with a dedicated user account. "
                                                "This user name <i>digikam</i> will require full access to the database.<br/>"
                                                "If your database is not already set up, you can use the following SQL commands "
                                                "(after replacing the <b><i>password</i></b> with the correct one).</p>"),
                                           d->dbNoticeBox);
     notice->setWordWrap(true);
 
     d->sqlInit               = new QTextBrowser(d->dbNoticeBox);
     d->sqlInit->setOpenExternalLinks(false);
     d->sqlInit->setOpenLinks(false);
     d->sqlInit->setReadOnly(false);
 
     QLabel* const notice2    = new QLabel(i18n("<p>Note: with a Linux server, a database can be initialized following the commands below:</p>"
                                                "<p># su</p>"
                                                "<p># systemctl restart mysqld</p>"
                                                "<p># mysql -u root</p>"
                                                "<p>...</p>"
                                                "<p>Enter SQL code to Mysql prompt in order to init digiKam databases with grant privileges (see behind)</p>"
                                                "<p>...</p>"
                                                "<p>quit</p>"
                                                "<p>NOTE: If you have an enormous collection, you should start MySQL server with "
                                                "mysql --max_allowed_packet=128M OR in my.ini or ~/.my.cnf, change the settings</p><p></p>"),
                                           d->dbNoticeBox);
     notice2->setWordWrap(true);
     notice2->setSizePolicy(QSizePolicy::MinimumExpanding,
                            QSizePolicy::MinimumExpanding);
 
     vlay2->addWidget(notice);
     vlay2->addWidget(d->sqlInit);
     vlay2->addWidget(notice2);
     vlay2->setContentsMargins(spacing, spacing, spacing, spacing);
     vlay2->setSpacing(spacing);
 
     d->tab->addTab(d->dbNoticeBox, i18n("Requirements"));
 
     // --------------------------------------------------------
 
     d->dbDetailsBox          = new QGroupBox(i18n("Database Server Technical Details"), this);
     QVBoxLayout* const vlay3 = new QVBoxLayout(d->dbDetailsBox);
     QLabel* const details    = new QLabel(i18n("<p>Use this configuration view to set all information "
                                                "to be connected to a remote "
                                                "<a href=\"https://en.wikipedia.org/wiki/MySQL\">Mysql database server</a> "
                                                "(or <a href=\"https://en.wikipedia.org/wiki/MariaDB\">MariaDB</a>) "
                                                "through a network. "
                                                "As with Sqlite or MySQL internal server, 3 databases will be stored "
                                                "on the remote server: one for all collections properties, "
                                                "one to store compressed thumbnails, and one to store faces "
                                                "recognition metadata.</p>"
                                                "<p>Unlike Sqlite or MySQL internal server, you can customize the "
                                                "database names to simplify your backups.</p>"
                                                "<p>Databases are digiKam core engines. To prevent performance issues, "
                                                "take a care to use a fast network link between the client and the server "
                                                "computers. It is also recommended to host database files on "
                                                "fast hardware (as <a href=\"https://en.wikipedia.org/wiki/Solid-state_drive\">SSD</a>) "
                                                "with enough free space, especially for thumbnails database, even if data are compressed using wavelets image format <a href=\"https://en.wikipedia.org/wiki/Progressive_Graphics_File\">"
                                                "PGF</a>.</p>"
                                                "<p>The databases must be created previously on the remote server by the administrator. "
                                                "Look in <b>Requirements</b> tab for details.</p>"),
                                           d->dbDetailsBox);
     details->setWordWrap(true);
     details->setSizePolicy(QSizePolicy::MinimumExpanding,
                            QSizePolicy::MinimumExpanding);
 
     vlay3->addWidget(details);
     vlay3->setContentsMargins(spacing, spacing, spacing, spacing);
     vlay3->setSpacing(spacing);
 
     d->tab->addTab(d->dbDetailsBox, i18n("Documentation"));
 
     // --------------------------------------------------------
 
     vlay->addWidget(typeHbox);
     vlay->addWidget(new DLineWidget(Qt::Horizontal));
     vlay->addWidget(d->dbPathLabel);
     vlay->addWidget(d->dbPathEdit);
     vlay->addWidget(d->mysqlCmdBox);
     vlay->addWidget(d->tab);
     vlay->setContentsMargins(spacing, spacing, spacing, spacing);
     vlay->setSpacing(spacing);
 
     // --------------------------------------------------------
 
     layout->setContentsMargins(QMargins());
     layout->setSpacing(spacing);
     layout->addWidget(dbConfigBox);
     layout->addStretch();
 
     // --------------------------------------------------------
 
     connect(d->dbType, SIGNAL(currentIndexChanged(int)),
             this, SLOT(slotHandleDBTypeIndexChanged(int)));
 
     connect(checkDBConnectBtn, SIGNAL(clicked()),
             this, SLOT(slotCheckMysqlServerConnection()));
 
     connect(defaultValuesBtn, SIGNAL(clicked()),
             this, SLOT(slotResetMysqlServerDBNames()));
 
     connect(d->dbNameCore, SIGNAL(textChanged(QString)),
             this, SLOT(slotUpdateSqlInit()));
 
     connect(d->dbNameThumbs, SIGNAL(textChanged(QString)),
             this, SLOT(slotUpdateSqlInit()));
 
     connect(d->dbNameFace, SIGNAL(textChanged(QString)),
             this, SLOT(slotUpdateSqlInit()));
 
     connect(d->dbNameSimilarity, SIGNAL(textChanged(QString)),
             this, SLOT(slotUpdateSqlInit()));
 
     connect(d->userName, SIGNAL(textChanged(QString)),
             this, SLOT(slotUpdateSqlInit()));
 
     slotHandleDBTypeIndexChanged(d->dbType->currentIndex());
 }
 
 int DatabaseSettingsWidget::databaseType() const
 {
     return d->dbType->currentData().toInt();
 }
 
 QString DatabaseSettingsWidget::databasePath() const
 {
     return d->dbPathEdit->fileDlgPath();
 }
 
 void DatabaseSettingsWidget::setDatabasePath(const QString& path)
 {
     d->dbPathEdit->setFileDlgPath(path);
 }
 
 DbEngineParameters DatabaseSettingsWidget::orgDatabasePrm() const
 {
     return d->orgPrms;
 }
 
 QString DatabaseSettingsWidget::databaseBackend() const
 {
     switch (databaseType())
     {
         case MysqlInternal:
         case MysqlServer:
         {
             return DbEngineParameters::MySQLDatabaseType();
         }
 
         default: // SQlite
         {
             return DbEngineParameters::SQLiteDatabaseType();
         }
     }
 }
 
 void DatabaseSettingsWidget::slotResetMysqlServerDBNames()
 {
     d->dbNameCore->setText(QLatin1String("digikam"));
     d->dbNameThumbs->setText(QLatin1String("digikam"));
     d->dbNameFace->setText(QLatin1String("digikam"));
     d->dbNameSimilarity->setText(QLatin1String("digikam"));
 }
 
 void DatabaseSettingsWidget::slotHandleDBTypeIndexChanged(int index)
 {
     int dbType = d->dbType->itemData(index).toInt();
     setDatabaseInputFields(dbType);
     handleInternalServer(dbType);
     slotUpdateSqlInit();
 }
 
 void DatabaseSettingsWidget::setDatabaseInputFields(int index)
 {
     switch (index)
     {
         case SQlite:
         {
             d->dbPathLabel->setVisible(true);
             d->dbPathEdit->setVisible(true);
             d->mysqlCmdBox->setVisible(false);
             d->tab->setVisible(false);
 
             connect(d->dbPathEdit->lineEdit(), SIGNAL(textChanged(QString)),
                     this, SLOT(slotDatabasePathEditedDelayed()));
 
             break;
         }
 
         case MysqlInternal:
         {
             d->dbPathLabel->setVisible(true);
             d->dbPathEdit->setVisible(true);
             d->mysqlCmdBox->setVisible(true);
             d->tab->setVisible(false);
 
             connect(d->dbPathEdit->lineEdit(), SIGNAL(textChanged(QString)),
                     this, SLOT(slotDatabasePathEditedDelayed()));
 
             break;
         }
 
         default: // MysqlServer
         {
             d->dbPathLabel->setVisible(false);
             d->dbPathEdit->setVisible(false);
             d->mysqlCmdBox->setVisible(false);
             d->tab->setVisible(true);
 
             disconnect(d->dbPathEdit->lineEdit(), SIGNAL(textChanged(QString)),
                        this, SLOT(slotDatabasePathEditedDelayed()));
             break;
         }
     }
 }
 
 void DatabaseSettingsWidget::handleInternalServer(int index)
 {
     bool internal = (index == MysqlInternal);
 
     d->hostName->setDisabled(internal);
     d->hostPort->setDisabled(internal);
     d->dbNameCore->setDisabled(internal);
     d->dbNameThumbs->setDisabled(internal);
     d->dbNameFace->setDisabled(internal);
     d->dbNameSimilarity->setDisabled(internal);
     d->userName->setDisabled(internal);
     d->password->setDisabled(internal);
     d->connectOpts->setDisabled(internal);
 }
 
 void DatabaseSettingsWidget::slotUpdateSqlInit()
 {
     QString sql = QString::fromLatin1("CREATE USER \'%1\'@\'%2\' IDENTIFIED BY \'<b>password</b>\';<br>")
                                       .arg(d->userName->text())
                                       .arg(d->hostName->text());
 
     sql += QString::fromLatin1("GRANT ALL ON *.* TO \'%1\'@\'%2\' IDENTIFIED BY \'<b>password</b>\';<br>")
                                .arg(d->userName->text())
                                .arg(d->hostName->text());
 
     sql += QString::fromLatin1("CREATE DATABASE %1;<br>"
                                "GRANT ALL PRIVILEGES ON %2.* TO \'%3\'@\'%4\';<br>")
                                .arg(d->dbNameCore->text())
                                .arg(d->dbNameCore->text())
                                .arg(d->userName->text())
                                .arg(d->hostName->text());
 
     if (d->dbNameThumbs->text() != d->dbNameCore->text())
     {
         sql += QString::fromLatin1("CREATE DATABASE %1;<br>"
                                    "GRANT ALL PRIVILEGES ON %2.* TO \'%3\'@\'%4\';<br>")
                                    .arg(d->dbNameThumbs->text())
                                    .arg(d->dbNameThumbs->text())
                                    .arg(d->userName->text())
                                    .arg(d->hostName->text());
     }
 
     if ((d->dbNameFace->text() != d->dbNameCore->text()) &&
         (d->dbNameFace->text() != d->dbNameThumbs->text()))
     {
         sql += QString::fromLatin1("CREATE DATABASE %1;<br>"
                                    "GRANT ALL PRIVILEGES ON %2.* TO \'%3\'@\'%4\';<br>")
                                    .arg(d->dbNameFace->text())
                                    .arg(d->dbNameFace->text())
                                    .arg(d->userName->text())
                                    .arg(d->hostName->text());
     }
 
     if ((d->dbNameSimilarity->text() != d->dbNameCore->text()) &&
         (d->dbNameSimilarity->text() != d->dbNameThumbs->text()) &&
         (d->dbNameSimilarity->text() != d->dbNameFace->text()))
     {
         sql += QString::fromLatin1("CREATE DATABASE %1;<br>"
                                    "GRANT ALL PRIVILEGES ON %2.* TO \'%3\'@\'%4\';<br>")
                                    .arg(d->dbNameSimilarity->text())
                                    .arg(d->dbNameSimilarity->text())
                                    .arg(d->userName->text())
                                    .arg(d->hostName->text());
     }
 
     sql += QLatin1String("FLUSH PRIVILEGES;<br>");
 
     d->sqlInit->setText(sql);
 }
 
 void DatabaseSettingsWidget::slotCheckMysqlServerConnection()
 {
     QString error;
 
     if (checkMysqlServerConnection(error))
     {
         QMessageBox::information(qApp->activeWindow(), i18n("Database connection test"),
                                  i18n("Database connection test successful."));
     }
     else
     {
         QMessageBox::critical(qApp->activeWindow(), i18n("Database connection test"),
                               i18n("Database connection test was not successful. <p>Error was: %1</p>",
                                    error));
     }
 }
 
 bool DatabaseSettingsWidget::checkMysqlServerConnectionConfig(QString& error)
 {
     if (d->hostName->text().isEmpty())
     {
         error = i18n("The server hostname is empty");
         return false;
     }
 
     if (d->userName->text().isEmpty())
     {
         error = i18n("The server user name is empty");
         return false;
     }
 
     return true;
 }
 
 bool DatabaseSettingsWidget::checkMysqlServerDbNamesConfig(QString& error)
 {
     if (d->dbNameCore->text().isEmpty())
     {
         error = i18n("The core database name is empty");
         return false;
     }
 
     if (d->dbNameThumbs->text().isEmpty())
     {
         error = i18n("The thumbnails database name is empty");
         return false;
     }
 
     if (d->dbNameFace->text().isEmpty())
     {
         error = i18n("The face database name is empty");
         return false;
     }
 
     if (d->dbNameSimilarity->text().isEmpty())
     {
         error = i18n("The similarity database name is empty");
         return false;
     }
 
     return true;
 }
 
 bool DatabaseSettingsWidget::checkMysqlServerConnection(QString& error)
 {
     if (!checkMysqlServerConnectionConfig(error))
     {
         return false;
     }
 
     bool result = false;
 
     qApp->setOverrideCursor(Qt::WaitCursor);
 
     AlbumManager::instance()->addFakeConnection();
 
     QString databaseID(QLatin1String("ConnectionTest"));
 
     {
         QSqlDatabase testDatabase = QSqlDatabase::addDatabase(databaseBackend(), databaseID);
 
         DbEngineParameters prm    = getDbEngineParameters();
         qCDebug(DIGIKAM_DATABASE_LOG) << "Testing DB connection (" << databaseID << ") with these settings:";
         qCDebug(DIGIKAM_DATABASE_LOG) << prm;
 
         testDatabase.setHostName(prm.hostName);
         testDatabase.setPort(prm.port);
         testDatabase.setUserName(prm.userName);
         testDatabase.setPassword(prm.password);
         testDatabase.setConnectOptions(prm.connectOptions);
 
         result = testDatabase.open();
         error  = testDatabase.lastError().text();
         testDatabase.close();
     }
 
     QSqlDatabase::removeDatabase(databaseID);
 
     qApp->restoreOverrideCursor();
 
     return result;
 }
 
 void DatabaseSettingsWidget::setParametersFromSettings(const ApplicationSettings* const settings,
                                                        const bool& migration)
 {
     d->orgPrms = settings->getDbEngineParameters();
 
     if (d->orgPrms.databaseType == DbEngineParameters::SQLiteDatabaseType())
     {
         d->dbPathEdit->setFileDlgPath(d->orgPrms.getCoreDatabaseNameOrDir());
         d->dbType->setCurrentIndex(d->dbTypeMap[SQlite]);
         slotResetMysqlServerDBNames();
 
         if (settings->getDatabaseDirSetAtCmd() && !migration)
         {
             d->dbType->setEnabled(false);
             d->dbPathEdit->setEnabled(false);
             d->dbPathLabel->setText(d->dbPathLabel->text() +
                                     i18n("This path was set as a command line"
                                          "option (--database-directory)."));
         }
     }
 #ifdef HAVE_MYSQLSUPPORT
 
 #   ifdef HAVE_INTERNALMYSQL
     else if (d->orgPrms.databaseType == DbEngineParameters::MySQLDatabaseType() && d->orgPrms.internalServer)
     {
         d->dbPathEdit->setFileDlgPath(d->orgPrms.internalServerPath());
         d->dbType->setCurrentIndex(d->dbTypeMap[MysqlInternal]);
         d->mysqlInitBin.setup(QFileInfo(d->orgPrms.internalServerMysqlInitCmd).absoluteFilePath());
         d->mysqlServBin.setup(QFileInfo(d->orgPrms.internalServerMysqlServCmd).absoluteFilePath());
         d->dbBinariesWidget->allBinariesFound();
         slotResetMysqlServerDBNames();
     }
 #   endif
     else
     {
         d->dbType->setCurrentIndex(d->dbTypeMap[MysqlServer]);
         d->dbNameCore->setText(d->orgPrms.databaseNameCore);
         d->dbNameThumbs->setText(d->orgPrms.databaseNameThumbnails);
         d->dbNameFace->setText(d->orgPrms.databaseNameFace);
         d->dbNameSimilarity->setText(d->orgPrms.databaseNameSimilarity);
         d->hostName->setText(d->orgPrms.hostName);
         d->hostPort->setValue((d->orgPrms.port == -1) ? 3306 : d->orgPrms.port);
         d->connectOpts->setText(d->orgPrms.connectOptions);
         d->userName->setText(d->orgPrms.userName);
         d->password->setText(d->orgPrms.password);
     }
 #endif
 
     slotHandleDBTypeIndexChanged(d->dbType->currentIndex());
 }
 
 DbEngineParameters DatabaseSettingsWidget::getDbEngineParameters() const
 {
     DbEngineParameters prm;
 
     switch(databaseType())
     {
         case SQlite:
             prm = DbEngineParameters::parametersForSQLiteDefaultFile(databasePath());
             break;
 
         case MysqlInternal:
             prm = DbEngineParameters::defaultParameters(databaseBackend());
             prm.setInternalServerPath(databasePath());
             prm.internalServerMysqlInitCmd = d->mysqlInitBin.path();
             prm.internalServerMysqlServCmd = d->mysqlServBin.path();
             break;
 
         default: // MysqlServer
             prm.internalServer         = false;
             prm.databaseType           = databaseBackend();
             prm.databaseNameCore       = d->dbNameCore->text();
             prm.databaseNameThumbnails = d->dbNameThumbs->text();
             prm.databaseNameFace       = d->dbNameFace->text();
             prm.databaseNameSimilarity = d->dbNameSimilarity->text();
             prm.connectOptions         = d->connectOpts->text();
             prm.hostName               = d->hostName->text();
             prm.port                   = d->hostPort->value();
             prm.userName               = d->userName->text();
             prm.password               = d->password->text();
             break;
     }
 
     return prm;
 }
 
 void DatabaseSettingsWidget::slotDatabasePathEditedDelayed()
 {
     QTimer::singleShot(300, this, SLOT(slotDatabasePathEdited()));
 }
 
 void DatabaseSettingsWidget::slotDatabasePathEdited()
 {
     QString newPath = databasePath();
 
 #ifndef Q_OS_WIN
 
     if (!newPath.isEmpty() && !QDir::isAbsolutePath(newPath))
     {
         d->dbPathEdit->setFileDlgPath(QDir::homePath() + QLatin1Char('/') + newPath);
     }
 
 #endif
 
     d->dbPathEdit->setFileDlgPath(newPath);
 }
 
 bool DatabaseSettingsWidget::checkDatabaseSettings()
 {
     switch (databaseType())
     {
         case SQlite:
         {
             return checkDatabasePath();
         }
 
         case MysqlInternal:
         {
             if (!checkDatabasePath())
                 return false;
 
             if (!d->dbBinariesWidget->allBinariesFound())
                 return false;
 
             return true;
         }
 
         default:  // MysqlServer
         {
             QString error;
 
             if (!checkMysqlServerDbNamesConfig(error))
             {
                 QMessageBox::critical(qApp->activeWindow(), i18n("Database Configuration"),
                                       i18n("The database names configuration is not valid. Error is <br/><p>%1</p><br/>"
                                            "Please check your configuration.",
                                            error));
                 return false;
             }
 
             if (!checkMysqlServerConnection(error))
             {
                 QMessageBox::critical(qApp->activeWindow(), i18n("Database Connection Test"),
                                       i18n("Testing database connection has failed with error<br/><p>%1</p><br/>"
                                            "Please check your configuration.",
                                            error));
                 return false;
             }
         }
     }
 
     return true;
 }
 
 bool DatabaseSettingsWidget::checkDatabasePath()
 {
     QString dbFolder = databasePath();
     qCDebug(DIGIKAM_DATABASE_LOG) << "Database directory is : " << dbFolder;
 
     if (dbFolder.isEmpty())
     {
         QMessageBox::information(qApp->activeWindow(), qApp->applicationName(),
                                 i18n("You must select a folder for digiKam to "
                                      "store information and metadata in a database file."));
         return false;
     }
 
     QDir targetPath(dbFolder);
 
     if (!targetPath.exists())
     {
         int rc = QMessageBox::question(qApp->activeWindow(), i18n("Create Database Folder?"),
                                     i18n("<p>The folder to put your database in does not seem to exist:</p>"
                                          "<p><b>%1</b></p>"
                                          "Would you like digiKam to create it for you?", dbFolder));
 
         if (rc == QMessageBox::No)
         {
             return false;
         }
 
         if (!targetPath.mkpath(dbFolder))
         {
             QMessageBox::information(qApp->activeWindow(), i18n("Create Database Folder Failed"),
                                     i18n("<p>digiKam could not create the folder to host your database file.\n"
                                          "Please select a different location.</p>"
                                          "<p><b>%1</b></p>", dbFolder));
             return false;
         }
     }
 
     QFileInfo path(dbFolder);
 
 #ifdef Q_OS_WIN
+
     // Work around bug #189168
+
     QTemporaryFile temp;
-    temp.setFileTemplate(dbFolder + QLatin1String("XXXXXX"));
+    temp.setFileTemplate(path.filePath() + QLatin1String("/XXXXXX"));
 
     if (!temp.open())
+
 #else
+
     if (!path.isWritable())
+
 #endif
     {
         QMessageBox::information(qApp->activeWindow(), i18n("No Database Write Access"),
                                  i18n("<p>You do not seem to have write access "
                                       "for the folder to host the database file.<br/>"
                                       "Please select a different location.</p>"
                                       "<p><b>%1</b></p>", dbFolder));
         return false;
     }
 
     return true;
 }
 
 } // namespace Digikam
diff --git a/core/libs/fileactionmanager/databaseworkeriface.cpp b/core/libs/fileactionmanager/databaseworkeriface.cpp
index 2b20218a31..4850f3e3a3 100644
--- a/core/libs/fileactionmanager/databaseworkeriface.cpp
+++ b/core/libs/fileactionmanager/databaseworkeriface.cpp
@@ -1,388 +1,389 @@
 /* ============================================================
  *
  * This file is a part of digiKam project
  * https://www.digikam.org
  *
  * Date        : 2012-01-18
  * Description : database worker interface
  *
  * Copyright (C) 2012 by Marcel Wiesweg <marcel dot wiesweg at gmx dot 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, 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.
  *
  * ============================================================ */
 
 #include "databaseworkeriface.h"
 
 // KDE includes
 
 #include <klocalizedstring.h>
 
 // Local includes
 
 #include "digikam_debug.h"
 #include "collectionscanner.h"
 #include "coredboperationgroup.h"
 #include "iteminfotasksplitter.h"
 #include "fileactionmngr_p.h"
 #include "scancontroller.h"
 #include "disjointmetadata.h"
+#include "faceutils.h"
 
 namespace Digikam
 {
 
 void FileActionMngrDatabaseWorker::assignTags(FileActionItemInfoList infos, const QList<int>& tagIDs)
 {
     changeTags(infos, tagIDs, true);
 }
 
 void FileActionMngrDatabaseWorker::removeTags(FileActionItemInfoList infos, const QList<int>& tagIDs)
 {
     changeTags(infos, tagIDs, false);
 }
 
 void FileActionMngrDatabaseWorker::changeTags(FileActionItemInfoList infos,
                                               const QList<int>& tagIDs, bool addOrRemove)
 {
     DisjointMetadata hub;
     QList<ItemInfo> forWriting;
 
     {
         CoreDbOperationGroup group;
         group.setMaximumTime(200);
 
         foreach (const ItemInfo& info, infos)
         {
             if (state() == WorkerObject::Deactivating)
             {
                 break;
             }
 
             hub.load(info);
 
             for (QList<int>::const_iterator tagIt = tagIDs.constBegin() ; tagIt != tagIDs.constEnd() ; ++tagIt)
             {
                 if (addOrRemove)
                 {
                     hub.setTag(*tagIt, DisjointMetadata::MetadataAvailable);
                 }
                 else
                 {
                     hub.setTag(*tagIt, DisjointMetadata::MetadataInvalid);
                 }
             }
 
             hub.write(info, DisjointMetadata::PartialWrite);
 
             if (hub.willWriteMetadata(DisjointMetadata::FullWriteIfChanged) &&
                 d->shallSendForWriting(info.id()))
             {
                 forWriting << info;
             }
 
             infos.dbProcessedOne();
             group.allowLift();
         }
     }
 
     // send for writing file metadata
 
     if (!forWriting.isEmpty())
     {
         FileActionItemInfoList forWritingTaskList = FileActionItemInfoList::continueTask(forWriting, infos.progress());
         forWritingTaskList.schedulingForWrite(i18n("Writing metadata to files"), d->fileProgressCreator());
 
         qCDebug(DIGIKAM_GENERAL_LOG) << "Scheduled to write";
 
         for (ItemInfoTaskSplitter splitter(forWritingTaskList) ; splitter.hasNext() ; )
         {
             emit writeMetadata(FileActionItemInfoList(splitter.next()), MetadataHub::WRITE_TAGS);
         }
     }
 
     infos.dbFinished();
 }
 
 void FileActionMngrDatabaseWorker::assignPickLabel(FileActionItemInfoList infos, int pickId)
 {
     DisjointMetadata hub;
     QList<ItemInfo> forWriting;
 
     {
         CoreDbOperationGroup group;
         group.setMaximumTime(200);
 
         foreach (const ItemInfo& info, infos)
         {
             if (state() == WorkerObject::Deactivating)
             {
                 break;
             }
 
             hub.load(info);
             hub.setPickLabel(pickId);
             hub.write(info, DisjointMetadata::PartialWrite);
 
             if (hub.willWriteMetadata(DisjointMetadata::FullWriteIfChanged) &&
                 d->shallSendForWriting(info.id()))
             {
                 forWriting << info;
             }
 
             infos.dbProcessedOne();
             group.allowLift();
         }
     }
 
     // send for writing file metadata
 
     if (!forWriting.isEmpty())
     {
         FileActionItemInfoList forWritingTaskList = FileActionItemInfoList::continueTask(forWriting, infos.progress());
         forWritingTaskList.schedulingForWrite(i18n("Writing metadata to files"), d->fileProgressCreator());
 
         for (ItemInfoTaskSplitter splitter(forWritingTaskList) ; splitter.hasNext() ; )
         {
             emit writeMetadata(FileActionItemInfoList(splitter.next()), MetadataHub::WRITE_PICKLABEL);
         }
     }
 
     infos.dbFinished();
 }
 
 void FileActionMngrDatabaseWorker::assignColorLabel(FileActionItemInfoList infos, int colorId)
 {
     DisjointMetadata hub;
     QList<ItemInfo> forWriting;
 
     {
         CoreDbOperationGroup group;
         group.setMaximumTime(200);
 
         foreach (const ItemInfo& info, infos)
         {
             if (state() == WorkerObject::Deactivating)
             {
                 break;
             }
 
             hub.load(info);
             hub.setColorLabel(colorId);
             hub.write(info, DisjointMetadata::PartialWrite);
 
             if (hub.willWriteMetadata(DisjointMetadata::FullWriteIfChanged) &&
                 d->shallSendForWriting(info.id()))
             {
                 forWriting << info;
             }
 
             infos.dbProcessedOne();
             group.allowLift();
         }
     }
 
     // send for writing file metadata
 
     if (!forWriting.isEmpty())
     {
         FileActionItemInfoList forWritingTaskList = FileActionItemInfoList::continueTask(forWriting, infos.progress());
         forWritingTaskList.schedulingForWrite(i18n("Writing metadata to files"), d->fileProgressCreator());
 
         for (ItemInfoTaskSplitter splitter(forWritingTaskList) ; splitter.hasNext() ; )
         {
             emit writeMetadata(FileActionItemInfoList(splitter.next()), MetadataHub::WRITE_COLORLABEL);
         }
     }
 
     infos.dbFinished();
 }
 
 void FileActionMngrDatabaseWorker::assignRating(FileActionItemInfoList infos, int rating)
 {
     DisjointMetadata hub;
     QList<ItemInfo> forWriting;
     rating = qMin(RatingMax, qMax(RatingMin, rating));
 
     {
         CoreDbOperationGroup group;
         group.setMaximumTime(200);
 
         foreach (const ItemInfo& info, infos)
         {
             if (state() == WorkerObject::Deactivating)
             {
                 break;
             }
 
             hub.load(info);
             hub.setRating(rating);
             hub.write(info, DisjointMetadata::PartialWrite);
 
             if (hub.willWriteMetadata(DisjointMetadata::FullWriteIfChanged) &&
                 d->shallSendForWriting(info.id()))
             {
                 forWriting << info;
             }
 
             infos.dbProcessedOne();
             group.allowLift();
         }
     }
 
     // send for writing file metadata
 
     if (!forWriting.isEmpty())
     {
         FileActionItemInfoList forWritingTaskList = FileActionItemInfoList::continueTask(forWriting, infos.progress());
         forWritingTaskList.schedulingForWrite(i18n("Writing metadata to files"), d->fileProgressCreator());
 
         for (ItemInfoTaskSplitter splitter(forWritingTaskList) ; splitter.hasNext() ; )
         {
             emit writeMetadata(FileActionItemInfoList(splitter.next()), MetadataHub::WRITE_RATING);
         }
     }
 
     infos.dbFinished();
 }
 
 void FileActionMngrDatabaseWorker::editGroup(int groupAction, const ItemInfo& pick, FileActionItemInfoList infos)
 {
     {
         CoreDbOperationGroup group;
         group.setMaximumTime(200);
 
         foreach (const ItemInfo& constInfo, infos)
         {
             if (state() == WorkerObject::Deactivating)
             {
                 break;
             }
 
             ItemInfo info(constInfo);
 
             switch (groupAction)
             {
                 case AddToGroup:
                     info.addToGroup(pick);
                     break;
 
                 case RemoveFromGroup:
                     info.removeFromGroup();
                     break;
 
                 case Ungroup:
                     info.clearGroup();
                     break;
             }
 
             infos.dbProcessedOne();
             group.allowLift();
         }
     }
 
     infos.dbFinished();
 }
 
 void FileActionMngrDatabaseWorker::setExifOrientation(FileActionItemInfoList infos, int orientation)
 {
     {
         CoreDbOperationGroup group;
         group.setMaximumTime(200);
 
         foreach (ItemInfo info, infos)
         {
             if (state() == WorkerObject::Deactivating)
             {
                 break;
             }
 
-            MetadataHub hub;
-            hub.adjustFaceRectangles(info, false,
-                                           orientation,
-                                           info.orientation());
+            // Adjust Faces
+
+            FaceUtils().rotateFaces(info, orientation,
+                                          info.orientation());
 
             info.setOrientation(orientation);
         }
     }
 
     infos.dbProcessed(infos.count());
     infos.schedulingForWrite(infos.count(), i18n("Revising Exif Orientation tags"), d->fileProgressCreator());
 
     for (ItemInfoTaskSplitter splitter(infos) ; splitter.hasNext() ; )
     {
         emit writeOrientationToFiles(FileActionItemInfoList(splitter.next()), orientation);
     }
 
     infos.dbFinished();
 }
 
 void FileActionMngrDatabaseWorker::applyMetadata(FileActionItemInfoList infos, DisjointMetadata *hub)
 {
     {
         CoreDbOperationGroup group;
         group.setMaximumTime(200);
 
         foreach (const ItemInfo& info, infos)
         {
             if (state() == WorkerObject::Deactivating)
             {
                 break;
             }
 
             // apply to database
 
             hub->write(info);
             infos.dbProcessedOne();
             group.allowLift();
         }
     }
 
     if (hub->willWriteMetadata(DisjointMetadata::FullWriteIfChanged), Qt::DirectConnection)
     {
         int flags = hub->changedFlags();
 
         // don't filter by shallSendForWriting here; we write from the hub, not from freshly loaded data
 
         infos.schedulingForWrite(infos.size(), i18n("Writing metadata to files"), d->fileProgressCreator());
 
         for (ItemInfoTaskSplitter splitter(infos) ; splitter.hasNext() ; )
         {
             emit writeMetadata(FileActionItemInfoList(splitter.next()), flags);
         }
     }
 
     delete hub;
     infos.dbFinished();
 }
 
 void FileActionMngrDatabaseWorker::copyAttributes(FileActionItemInfoList infos, const QStringList& derivedPaths)
 {
     if (infos.size() == 1)
     {
         foreach (const QString& path, derivedPaths)
         {
             if (state() == WorkerObject::Deactivating)
             {
                 break;
             }
 
             ItemInfo dest = ScanController::instance()->scannedInfo(path);
             CollectionScanner::copyFileProperties(infos.first(), dest);
         }
 
         infos.dbProcessedOne();
     }
 
     infos.dbFinished();
 }
 
 } // namespace Digikam
diff --git a/core/libs/fileactionmanager/fileworkeriface.cpp b/core/libs/fileactionmanager/fileworkeriface.cpp
index 09ab9d9a6e..068a232119 100644
--- a/core/libs/fileactionmanager/fileworkeriface.cpp
+++ b/core/libs/fileactionmanager/fileworkeriface.cpp
@@ -1,331 +1,342 @@
 /* ============================================================
  *
  * This file is a part of digiKam project
  * https://www.digikam.org
  *
  * Date        : 2012-01-18
  * Description : database worker interface
  *
  * Copyright (C) 2012 by Marcel Wiesweg <marcel dot wiesweg at gmx dot 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, 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.
  *
  * ============================================================ */
 
 #include "fileworkeriface.h"
 
 // KDE includes
 
 #include <klocalizedstring.h>
 
 // Local includes
 
 #include "digikam_debug.h"
 #include "digikam_globals.h"
 #include "fileactionmngr_p.h"
 #include "metaenginesettings.h"
 #include "itemattributeswatch.h"
 #include "iteminfotasksplitter.h"
 #include "collectionscanner.h"
 #include "scancontroller.h"
+#include "faceutils.h"
 #include "jpegutils.h"
 #include "dimg.h"
 
 namespace Digikam
 {
 
 void FileActionMngrFileWorker::writeOrientationToFiles(FileActionItemInfoList infos, int orientation)
 {
     QStringList failedItems;
 
     foreach (const ItemInfo& info, infos)
     {
         if (state() == WorkerObject::Deactivating)
         {
             break;
         }
 
         QString path                  = info.filePath();
         DMetadata metadata(path);
         DMetadata::ImageOrientation o = (DMetadata::ImageOrientation)orientation;
         metadata.setItemOrientation(o);
 
         if (!metadata.applyChanges())
         {
             failedItems.append(info.name());
         }
         else
         {
             emit imageDataChanged(path, true, true);
             QUrl url = QUrl::fromLocalFile(path);
             ItemAttributesWatch::instance()->fileMetadataChanged(url);
         }
 
         infos.writtenToOne();
     }
 
     if (!failedItems.isEmpty())
     {
         emit imageChangeFailed(i18n("Failed to revise Exif orientation these files:"), failedItems);
     }
 
     infos.finishedWriting();
 }
 
 void FileActionMngrFileWorker::writeMetadataToFiles(FileActionItemInfoList infos)
 {
     d->startingToWrite(infos);
 
     ScanController::instance()->suspendCollectionScan();
 
     foreach (const ItemInfo& info, infos)
     {
         MetadataHub hub;
 
         if (state() == WorkerObject::Deactivating)
         {
             break;
         }
 
         hub.load(info);
         QString path = info.filePath();
 
         if (MetaEngineSettings::instance()->settings().useLazySync)
         {
             hub.write(path, MetadataHub::WRITE_ALL);
         }
         else
         {
             ScanController::FileMetadataWrite writeScope(info);
             writeScope.changed(hub.write(path, MetadataHub::WRITE_ALL));
         }
 
         // hub emits fileMetadataChanged
 
         infos.writtenToOne();
     }
 
     ScanController::instance()->resumeCollectionScan();
 
     infos.finishedWriting();
 }
 
 void FileActionMngrFileWorker::writeMetadata(FileActionItemInfoList infos, int flags)
 {
     d->startingToWrite(infos);
 
     ScanController::instance()->suspendCollectionScan();
 
     foreach (const ItemInfo& info, infos)
     {
         MetadataHub hub;
 
         if (state() == WorkerObject::Deactivating)
         {
             break;
         }
 
         hub.load(info);
 
         // apply to file metadata
 
         if (MetaEngineSettings::instance()->settings().useLazySync)
         {
             hub.writeToMetadata(info, (MetadataHub::WriteComponents)flags);
         }
         else
         {
             ScanController::FileMetadataWrite writeScope(info);
             writeScope.changed(hub.writeToMetadata(info, (MetadataHub::WriteComponents)flags));
         }
 
         // hub emits fileMetadataChanged
 
         infos.writtenToOne();
     }
 
     ScanController::instance()->resumeCollectionScan();
 
     infos.finishedWriting();
 }
 
 void FileActionMngrFileWorker::transform(FileActionItemInfoList infos, int action)
 {
     d->startingToWrite(infos);
 
     QStringList failedItems;
     ScanController::instance()->suspendCollectionScan();
 
     foreach (const ItemInfo& info, infos)
     {
         if (state() == WorkerObject::Deactivating)
         {
             break;
         }
 
         QString path                                    = info.filePath();
         QString format                                  = info.format();
         MetaEngine::ImageOrientation currentOrientation = (MetaEngine::ImageOrientation)info.orientation();
         bool isRaw                                      = info.format().startsWith(QLatin1String("RAW"));
         bool rotateAsJpeg                               = false;
         bool rotateLossy                                = false;
 
         MetaEngineSettingsContainer::RotationBehaviorFlags behavior;
         behavior              = MetaEngineSettings::instance()->settings().rotationBehavior;
         bool rotateByMetadata = (behavior & MetaEngineSettingsContainer::RotateByMetadataFlag);
 
         // Check if rotation by content, as desired, is feasible
         // We'll later check again if it was successful
 
         if (behavior & MetaEngineSettingsContainer::RotatingPixels)
         {
             if (format == QLatin1String("JPG") && JPEGUtils::isJpegImage(path))
             {
                 rotateAsJpeg = true;
             }
 
             if (behavior & MetaEngineSettingsContainer::RotateByLossyRotation)
             {
                 DImg::FORMAT frmt = DImg::fileFormat(path);
 
                 switch (frmt)
                 {
                     case DImg::JPEG:
                     case DImg::PNG:
                     case DImg::TIFF:
                     case DImg::JP2K:
                     case DImg::PGF:
                     case DImg::HEIF:
                         rotateLossy = true;
 
                     default:
                         break;
                 }
             }
         }
 
         MetaEngineRotation matrix;
         matrix                                        *= currentOrientation;
         matrix                                        *= (MetaEngineRotation::TransformationAction)action;
         MetaEngine::ImageOrientation finalOrientation  = matrix.exifOrientation();
         bool rotatedPixels                             = false;
 
         if (rotateAsJpeg)
         {
             JPEGUtils::JpegRotator rotator(path);
             rotator.setCurrentOrientation(currentOrientation);
 
             if (action == MetaEngineRotation::NoTransformation)
             {
                 rotatedPixels = rotator.autoExifTransform();
             }
             else
             {
                 rotatedPixels = rotator.exifTransform((MetaEngineRotation::TransformationAction)action);
             }
 
             if (!rotatedPixels)
             {
                 failedItems.append(info.name());
             }
         }
         else if (rotateLossy)
         {
             // Non-JPEG image: DImg
 
             DImg image;
 
             if (!image.load(path))
             {
                 failedItems.append(info.name());
             }
             else
             {
                 if (action == MetaEngineRotation::NoTransformation)
                 {
                     image.rotateAndFlip(currentOrientation);
                 }
                 else
                 {
                     image.transform(action);
                 }
 
                 // TODO: Atomic operation!!
                 // prepare metadata, including to reset Exif tag
 
                 image.prepareMetadataToSave(path, image.format(), true);
 
                 if (image.save(path, image.detectedFormat()))
                 {
                     rotatedPixels = true;
                 }
                 else
                 {
                     failedItems.append(info.name());
                 }
             }
         }
 
         int newOrientation = finalOrientation;
 
         if (rotatedPixels)
         {
             finalOrientation = MetaEngine::ORIENTATION_NORMAL;
         }
 
         // DB rotation
 
         ItemInfo(info).setOrientation(finalOrientation);
 
         // Adjust Faces
 
-        MetadataHub hub;
-        hub.adjustFaceRectangles(info, rotatedPixels,
-                                       newOrientation,
-                                       currentOrientation);
+        QSize newSize = FaceUtils().rotateFaces(info, newOrientation,
+                                                      currentOrientation);
+        if (newSize.isValid())
+        {
+            MetadataHub hub;
+            hub.load(info);
+
+            // Adjusted newSize
+
+            newSize = rotatedPixels ? newSize : info.dimensions();
+
+            hub.loadFaceTags(info, newSize);
+            hub.write(info.filePath(), MetadataHub::WRITE_TAGS, true);
+        }
 
         if (rotateByMetadata)
         {
             // Setting the rotation flag on Raws with embedded JPEG is a mess
             // Can apply to the RAW data, or to the embedded JPEG, or to both.
 
             if (!isRaw)
             {
                 DMetadata metadata(path);
                 metadata.setItemOrientation(finalOrientation);
                 metadata.applyChanges();
             }
         }
 
         CollectionScanner scanner;
         scanner.scanFile(info, CollectionScanner::NormalScan);
 
         if (!failedItems.contains(info.name()))
         {
             emit imageDataChanged(path, true, true);
             ItemAttributesWatch::instance()->fileMetadataChanged(info.fileUrl());
         }
 
         infos.writtenToOne();
     }
 
     if (!failedItems.isEmpty())
     {
         emit imageChangeFailed(i18n("Failed to transform these files:"), failedItems);
     }
 
     infos.finishedWriting();
 
     ScanController::instance()->resumeCollectionScan();
 }
 
 } // namespace Digikam
diff --git a/core/libs/fileactionmanager/metadatahub.cpp b/core/libs/fileactionmanager/metadatahub.cpp
index 3f44b1ec59..a94df4ae02 100644
--- a/core/libs/fileactionmanager/metadatahub.cpp
+++ b/core/libs/fileactionmanager/metadatahub.cpp
@@ -1,909 +1,824 @@
 /* ============================================================
  *
  * This file is a part of digiKam project
  * https://www.digikam.org
  *
  * Date        : 2007-01-05
  * Description : Metadata handling
  *
  * Copyright (C) 2007-2012 by Marcel Wiesweg <marcel dot wiesweg at gmx dot de>
  * Copyright (C) 2007-2020 by Gilles Caulier <caulier dot gilles at gmail dot com>
  * Copyright (C) 2014-2015 by Veaceslav Munteanu <veaceslav dot munteanu90 at gmail dot 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, 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.
  *
  * ============================================================ */
 
 #include "metadatahub.h"
 
 // Qt includes
 
 #include <QFileInfo>
 #include <QMutex>
 #include <QMutexLocker>
 
 // Local includes
 
 #include "digikam_debug.h"
 #include "coredbaccess.h"
 #include "coredbwatch.h"
 #include "iteminfo.h"
 #include "itemcomments.h"
 #include "itemposition.h"
 #include "template.h"
 #include "templatemanager.h"
 #include "applicationsettings.h"
 #include "itemattributeswatch.h"
 #include "tagscache.h"
 #include "facetagseditor.h"
 #include "metadatahubmngr.h"
 
 #ifdef HAVE_KFILEMETADATA
 #   include "baloowrap.h"
 #endif
 
 namespace Digikam
 {
 
 class Q_DECL_HIDDEN MetadataHub::Private
 {
 public:
 
     explicit Private()
       : pickLabel(-1),
         colorLabel(-1),
         rating(-1),
         count(0),
         dateTimeStatus(MetadataHub::MetadataInvalid),
         titlesStatus(MetadataHub::MetadataInvalid),
         commentsStatus(MetadataHub::MetadataInvalid),
         pickLabelStatus(MetadataHub::MetadataInvalid),
         colorLabelStatus(MetadataHub::MetadataInvalid),
         ratingStatus(MetadataHub::MetadataInvalid),
         templateStatus(MetadataHub::MetadataInvalid)
     {
     }
 
 public:
 
     int                               pickLabel;
     int                               colorLabel;
     int                               rating;
     int                               count;
 
     QDateTime                         dateTime;
 
     CaptionsMap                       titles;
     CaptionsMap                       comments;
 
     Template                          metadataTemplate;
 
     QMap<int, MetadataHub::Status>    tags;
 
     QStringList                       tagList;
 
     QMultiMap<QString, QVariant>      faceTagsList;
 
     ItemPosition                      itemPosition;
 
     MetadataHub::Status               dateTimeStatus;
     MetadataHub::Status               titlesStatus;
     MetadataHub::Status               commentsStatus;
     MetadataHub::Status               pickLabelStatus;
     MetadataHub::Status               colorLabelStatus;
     MetadataHub::Status               ratingStatus;
     MetadataHub::Status               templateStatus;
 
 public:
 
     template <class T> void loadSingleValue(const T& data, T& storage, MetadataHub::Status& status);
 };
 
 // ------------------------------------------------------------------------------------------
 
 MetadataHub::MetadataHub()
     : d(new Private)
 {
 }
 
 MetadataHub::MetadataHub(const MetadataHub& other)
     : d(new Private(*other.d))
 {
 }
 
 MetadataHub::~MetadataHub()
 {
     delete d;
 }
 
 MetadataHub& MetadataHub::operator=(const MetadataHub& other)
 {
     (*d) = (*other.d);
 
     return *this;
 }
 
 MetadataHub* MetadataHub::clone() const
 {
     return (new MetadataHub(*this));
 }
 
 void MetadataHub::reset()
 {
     (*d) = Private();
 }
 
 // --------------------------------------------------
 
 void MetadataHub::load(const ItemInfo& info)
 {
     d->count++;
 
     //qCDebug(DIGIKAM_GENERAL_LOG) << "---------------------------------Load from ItemInfo ----------------";
 
     CaptionsMap commentMap;
     CaptionsMap titleMap;
 
     {
         CoreDbAccess access;
         ItemComments comments = info.imageComments(access);
         commentMap            = comments.toCaptionsMap();
         titleMap              = comments.toCaptionsMap(DatabaseComment::Title);
     }
 
     Template tref = info.metadataTemplate();
     Template t    = TemplateManager::defaultManager()->findByContents(tref);
 
     //qCDebug(DIGIKAM_GENERAL_LOG) << "Found Metadata Template: " << t.templateTitle();
 
     load(info.dateTime(),
          titleMap,
          commentMap,
          info.colorLabel(),
          info.pickLabel(),
          info.rating(),
          t.isNull() ? tref : t);
 
     QList<int> tagIds = info.tagIds();
     loadTags(tagIds);
 
     loadFaceTags(info, info.dimensions());
 
     d->itemPosition = info.imagePosition();
 }
 
 // private common code to merge tags
 void MetadataHub::loadTags(const QList<int>& loadedTags)
 {
     d->tags.clear();
 
     foreach (int tagId, loadedTags)
     {
         if (TagsCache::instance()->isInternalTag(tagId))
         {
             continue;
         }
 
         d->tags[tagId] = MetadataAvailable;
     }
 }
 
 // private common code to load dateTime, comment, color label, pick label, rating
 void MetadataHub::load(const QDateTime& dateTime,
                        const CaptionsMap& titles, const CaptionsMap& comments,
                        int colorLabel, int pickLabel,
                        int rating, const Template& t)
 {
     if (dateTime.isValid())
     {
         d->loadSingleValue<QDateTime>(dateTime, d->dateTime, d->dateTimeStatus);
     }
 
     d->loadSingleValue<int>(pickLabel, d->pickLabel, d->pickLabelStatus);
 
     d->loadSingleValue<int>(colorLabel, d->colorLabel, d->colorLabelStatus);
 
     d->loadSingleValue<int>(rating, d->rating, d->ratingStatus);
 
     d->loadSingleValue<CaptionsMap>(titles, d->titles, d->titlesStatus);
 
     d->loadSingleValue<CaptionsMap>(comments, d->comments, d->commentsStatus);
 
     d->loadSingleValue<Template>(t, d->metadataTemplate, d->templateStatus);
 }
 
 // template method used by comment and template
 template <class T> void MetadataHub::Private::loadSingleValue(const T& data, T& storage,
                                                               MetadataHub::Status& status)
 {
     switch (status)
     {
         case MetadataHub::MetadataInvalid:
             storage = data;
             status  = MetadataHub::MetadataAvailable;
             break;
 
         case MetadataHub::MetadataAvailable:
             qCDebug(DIGIKAM_GENERAL_LOG) << "You should not load more than one image info in metadatahub";
             break;
     }
 }
 
 // ------------------------------------------------------------------------------------------------------------
 
 /** safe **/
 bool MetadataHub::writeToMetadata(const ItemInfo& info, WriteComponent writeMode, bool ignoreLazySync, const MetaEngineSettingsContainer &settings)
 {
     applyChangeNotifications();
 
     // if no DMetadata object is needed at all, don't construct one -
     // important optimization if writing to file is turned off in setup!
 
     if (!willWriteMetadata(writeMode, settings))
     {
         return false;
     }
 
     if (!ignoreLazySync && settings.useLazySync)
     {
         MetadataHubMngr::instance()->addPending(info);
 
         return true;
     }
 
     writeToBaloo(info.filePath());
 
     DMetadata metadata(info.filePath());
 
     if (write(metadata, writeMode, settings))
     {
         bool success = metadata.applyChanges();
         ItemAttributesWatch::instance()->fileMetadataChanged(QUrl::fromLocalFile(info.filePath()));
         return success;
     }
 
     return false;
 }
 
 bool MetadataHub::write(DMetadata& metadata, WriteComponent writeMode, const MetaEngineSettingsContainer& settings)
 {
     applyChangeNotifications();
 
     bool dirty = false;
 
     metadata.setSettings(settings);
 
     // find out in advance if we have something to write - needed for FullWriteIfChanged mode
     bool saveTitle      = (settings.saveComments   && (d->titlesStatus     == MetadataAvailable) && writeMode.testFlag(WRITE_TITLE));
     bool saveComment    = (settings.saveComments   && (d->commentsStatus   == MetadataAvailable) && writeMode.testFlag(WRITE_COMMENTS));
     bool saveDateTime   = (settings.saveDateTime   && (d->dateTimeStatus   == MetadataAvailable) && writeMode.testFlag(WRITE_DATETIME));
     bool savePickLabel  = (settings.savePickLabel  && (d->pickLabelStatus  == MetadataAvailable) && writeMode.testFlag(WRITE_PICKLABEL));
     bool saveColorLabel = (settings.saveColorLabel && (d->colorLabelStatus == MetadataAvailable) && writeMode.testFlag(WRITE_COLORLABEL));
     bool saveRating     = (settings.saveRating     && (d->ratingStatus     == MetadataAvailable) && writeMode.testFlag(WRITE_RATING));
     bool saveTemplate   = (settings.saveTemplate   && (d->templateStatus   == MetadataAvailable) && writeMode.testFlag(WRITE_TEMPLATE));
     bool saveTags       = (settings.saveTags       && writeMode.testFlag(WRITE_TAGS));
     bool saveFaces      = (settings.saveFaceTags   && writeMode.testFlag(WRITE_TAGS));
     bool savePosition   = (settings.savePosition   && writeMode.testFlag(WRITE_POSITION));
 
     if (saveTitle)
     {
         // Store titles in image as Iptc Object name and Xmp.
         dirty |= metadata.setItemTitles(d->titles);
     }
 
     if (saveComment)
     {
         // Store comments in image as JFIF comments, Exif comments, Iptc Caption, and Xmp.
         dirty |= metadata.setItemComments(d->comments);
     }
 
     if (saveDateTime)
     {
         // Store Image Date & Time as Exif and Iptc tags.
         dirty |= metadata.setImageDateTime(d->dateTime, false);
     }
 
     if (savePickLabel)
     {
         // Store Image Pick Label as XMP tag.
         dirty |= metadata.setItemPickLabel(d->pickLabel);
     }
 
     if (saveColorLabel)
     {
         // Store Image Color Label as XMP tag.
         dirty |= metadata.setItemColorLabel(d->colorLabel);
     }
 
     if (saveRating)
     {
         // Store Image rating as Iptc tag.
         dirty |= metadata.setItemRating(d->rating);
     }
 
     if (saveTemplate)
     {
         QString title = d->metadataTemplate.templateTitle();
 
         if (title == Template::removeTemplateTitle())
         {
             dirty |= metadata.removeMetadataTemplate();
         }
         else if (title.isEmpty())
         {
             // Nothing to do.
         }
         else
         {
             // Store metadata template as XMP tag.
             dirty |= metadata.removeMetadataTemplate();
             dirty |= metadata.setMetadataTemplate(d->metadataTemplate);
         }
     }
 
     if (savePosition)
     {
         if (d->itemPosition.hasCoordinates())
         {
             dirty |= metadata.setGPSInfo(d->itemPosition.altitude(),
                                          d->itemPosition.latitudeNumber(),
                                          d->itemPosition.longitudeNumber());
         }
         else
         {
             dirty |= metadata.removeGPSInfo();
         }
     }
 
     dirty |= metadata.setItemFacesMap(d->faceTagsList, saveFaces);
 
     dirty |= writeTags(metadata, saveTags);
 
     return dirty;
 }
 
 bool MetadataHub::write(const QString& filePath, WriteComponent writeMode, bool ignoreLazySync, const MetaEngineSettingsContainer& settings)
 {
     applyChangeNotifications();
 
     // if no DMetadata object is needed at all, don't construct one -
     // important optimization if writing to file is turned off in setup!
 
     if (!willWriteMetadata(writeMode, settings))
     {
         return false;
     }
 
     if (!ignoreLazySync && settings.useLazySync)
     {
         ItemInfo info = ItemInfo::fromLocalFile(filePath);
         MetadataHubMngr::instance()->addPending(info);
 
         return true;
     }
 
     writeToBaloo(filePath);
 
     DMetadata metadata(filePath);
 
     if (write(metadata, writeMode, settings))
     {
         bool success = metadata.applyChanges();
         ItemAttributesWatch::instance()->fileMetadataChanged(QUrl::fromLocalFile(filePath));
 
         return success;
     }
 
     return false;
 }
 
 bool MetadataHub::write(DImg& image, WriteComponent writeMode, bool ignoreLazySync, const MetaEngineSettingsContainer& settings)
 {
     applyChangeNotifications();
 
     // if no DMetadata object is needed at all, don't construct one
 
     if (!willWriteMetadata(writeMode, settings))
     {
         return false;
     }
 
     // See DImgLoader::readMetadata() and saveMetadata()
 
     DMetadata metadata;
     metadata.setData(image.getMetadata());
 
     QString filePath = image.originalFilePath();
 
     if (filePath.isEmpty())
     {
         filePath = image.lastSavedFilePath();
     }
 
     if (!ignoreLazySync && settings.useLazySync && !filePath.isEmpty())
     {
         ItemInfo info = ItemInfo::fromLocalFile(filePath);
         MetadataHubMngr::instance()->addPending(info);
 
         return true;
     }
 
     if (!filePath.isEmpty())
     {
         writeToBaloo(filePath);
     }
 
     return write(metadata, writeMode, settings);
 }
 
 bool MetadataHub::writeTags(const QString& filePath, WriteComponent writeMode,
                             const MetaEngineSettingsContainer& settings)
 {
     applyChangeNotifications();
 
     // if no DMetadata object is needed at all, don't construct one -
     // important optimization if writing to file is turned off in setup!
 
     if (!willWriteMetadata(writeMode, settings))
     {
         return false;
     }
 
     DMetadata metadata(filePath);
     metadata.setSettings(settings);
     bool saveFaces = settings.saveFaceTags;
     bool saveTags  = settings.saveTags;
 
     if (saveFaces)
     {
         metadata.setItemFacesMap(d->faceTagsList, true);
     }
     else
     {
         metadata.setItemFacesMap(d->faceTagsList, false);
     }
 
     writeToBaloo(filePath);
 
     if (writeTags(metadata, saveTags))
     {
         bool success = metadata.applyChanges();
         ItemAttributesWatch::instance()->fileMetadataChanged(QUrl::fromLocalFile(filePath));
 
         return success;
     }
     else
     {
         return false;
     }
 }
 
 bool MetadataHub::writeTags(DMetadata& metadata, bool saveTags)
 {
     qCDebug(DIGIKAM_GENERAL_LOG) << "Writing tags";
 
     bool dirty = false;
 
     if (saveTags)
     {
         // Store tag paths as Iptc keywords tags.
         // DatabaseMode == ManagedTags is assumed.
         // To fix this constraint (not needed currently), an oldKeywords parameter is needed
         // create list of keywords to be added and to be removed
 
         QStringList tagsPathList, newKeywords;
 
         QList<int> keys = d->tags.keys();
 
         foreach (int tagId, keys)
         {
             if (!TagsCache::instance()->canBeWrittenToMetadata(tagId))
             {
                 continue;
             }
 
             // WARNING: Do not use write(QFilePath ...) when multiple image info are loaded
             // otherwise disjoint tags will not be used, use writeToMetadata(ItemInfo...)
 
             if (d->tags.value(tagId) == MetadataAvailable)
             {
                 // This works for single and multiple selection.
                 // In both situations, tags which had originally been loaded
                 // have explicitly been removed with setTag.
 
                 QString tagName = TagsCache::instance()->tagName(tagId);
                 QString tagPath = TagsCache::instance()->tagPath(tagId, TagsCache::NoLeadingSlash);
 
                 if (!tagsPathList.contains(tagPath))
                 {
                     tagsPathList << tagPath;
                 }
 
                 if (!tagName.isEmpty())
                 {
                     newKeywords << tagName;
                 }
             }
         }
 
         tagsPathList = cleanupTags(tagsPathList);
         newKeywords = cleanupTags(newKeywords);
 
         if (!newKeywords.isEmpty())
         {
             qCDebug(DIGIKAM_GENERAL_LOG) << "-------------------------- New Keywords" << newKeywords;
 
             // NOTE: See bug #175321 : we remove all old keyword from IPTC and XMP before to
             // synchronize metadata, else contents is not coherent.
 
             dirty |= metadata.setItemTagsPath(tagsPathList);
         }
         else
         {
             qCDebug(DIGIKAM_GENERAL_LOG) << "Delete all keywords";
 
             // Delete all IPTC and XMP keywords
 
             dirty |= metadata.setItemTagsPath(QStringList());
         }
     }
 
     return dirty;
 }
 
 QStringList MetadataHub::cleanupTags(const QStringList& toClean)
 {
     QSet<QString> deduplicator;
 
     for (int index = 0 ; index < toClean.size() ; ++index)
     {
         QString keyword = toClean.at(index);
 
         if (!keyword.isEmpty())
         {
             // _Digikam_root_tag_ is present in some photos tagged with older
             // version of digiKam, must be removed
 
             if (keyword.contains(QRegExp(QLatin1String("(_Digikam_root_tag_/|/_Digikam_root_tag_|_Digikam_root_tag_)"))))
             {
                 keyword = keyword.replace(QRegExp(QLatin1String("(_Digikam_root_tag_/|/_Digikam_root_tag_|_Digikam_root_tag_)")),
                                           QLatin1String(""));
             }
 
             deduplicator.insert(keyword);
         }
     }
 
     return deduplicator.values();
 }
 
 bool MetadataHub::willWriteMetadata(WriteComponent writeMode, const MetaEngineSettingsContainer& settings) const
 {
     // This is the same logic as in write(DMetadata) but without actually writing.
     // Adapt if the method above changes
 
     bool saveTitle      = (settings.saveComments   && (d->titlesStatus     == MetadataAvailable) && writeMode.testFlag(WRITE_TITLE));
     bool saveComment    = (settings.saveComments   && (d->commentsStatus   == MetadataAvailable) && writeMode.testFlag(WRITE_COMMENTS));
     bool saveDateTime   = (settings.saveDateTime   && (d->dateTimeStatus   == MetadataAvailable) && writeMode.testFlag(WRITE_DATETIME));
     bool savePickLabel  = (settings.savePickLabel  && (d->pickLabelStatus  == MetadataAvailable) && writeMode.testFlag(WRITE_PICKLABEL));
     bool saveColorLabel = (settings.saveColorLabel && (d->colorLabelStatus == MetadataAvailable) && writeMode.testFlag(WRITE_COLORLABEL));
     bool saveRating     = (settings.saveRating     && (d->ratingStatus     == MetadataAvailable) && writeMode.testFlag(WRITE_RATING));
     bool saveTemplate   = (settings.saveTemplate   && (d->templateStatus   == MetadataAvailable) && writeMode.testFlag(WRITE_TEMPLATE));
     bool saveTags       = (settings.saveTags       && writeMode.testFlag(WRITE_TAGS));
     bool saveFaces      = (settings.saveFaceTags   && writeMode.testFlag(WRITE_TAGS));
     bool savePosition   = (settings.savePosition   && writeMode.testFlag(WRITE_POSITION));
 
     return (
                saveTitle       ||
                saveComment     ||
                saveDateTime    ||
                savePickLabel   ||
                saveColorLabel  ||
                saveRating      ||
                saveTemplate    ||
                saveTags        ||
                saveFaces       ||
                savePosition
            );
 }
 
 void MetadataHub::writeToBaloo(const QString& filePath, const MetaEngineSettingsContainer& settings)
 {
 #ifdef HAVE_KFILEMETADATA
 
     BalooWrap* const baloo = BalooWrap::instance();
     int rating             = -1;
     QString* comment       = nullptr;
 
     if (!baloo->getSyncToBaloo())
     {
         qCDebug(DIGIKAM_GENERAL_LOG) << "No write to baloo +++++++++++++++++++++++++++++++++++++";
         return;
     }
 
     bool saveComment = (settings.saveComments   && d->commentsStatus   == MetadataAvailable);
     bool saveRating  = (settings.saveRating     && d->ratingStatus     == MetadataAvailable);
 
     QStringList newKeywords;
 
     for (QMap<int, MetadataHub::Status>::iterator it = d->tags.begin() ; it != d->tags.end() ; ++it)
     {
         if (!TagsCache::instance()->canBeWrittenToMetadata(it.key()))
         {
             continue;
         }
 
         // it is important that MetadataDisjoint keywords are not touched
 
         if (it.value() == MetadataAvailable)
         {
             QString tagName = TagsCache::instance()->tagName(it.key());
 
             if (!tagName.isEmpty())
             {
                 newKeywords << tagName;
             }
         }
     }
 
     if (saveComment)
     {
         comment = new QString(d->comments.value(QLatin1String("x-default")).caption);
     }
 
     if (saveRating)
     {
         rating = d->rating;
     }
 
     newKeywords = cleanupTags(newKeywords);
     QUrl url    = QUrl::fromLocalFile(filePath);
     baloo->setAllData(url, &newKeywords, comment, rating);
 #else
     Q_UNUSED(filePath);
     Q_UNUSED(settings);
 #endif
 }
 
 void MetadataHub::applyChangeNotifications()
 {
 }
 
 void Digikam::MetadataHub::loadFaceTags(const ItemInfo& info, const QSize& size)
 {
     FaceTagsEditor editor;
 
     //qCDebug(DIGIKAM_GENERAL_LOG) << "Image Dimensions ----------------" << info.dimensions();
 
     QList<FaceTagsIface> facesList = editor.confirmedFaceTagsIfaces(info.id());
     d->faceTagsList.clear();
 
     if (!facesList.isEmpty())
     {
         foreach (const FaceTagsIface& dface, facesList)
         {
             QString faceName = FaceTags::faceNameForTag(dface.tagId());
 
             if (faceName.isEmpty())
             {
                 continue;
             }
 
             QRect  temprect = dface.region().toRect();
             TagRegion::reverseToOrientation(temprect, info.orientation(), size);
             QRectF faceRect = TagRegion::absoluteToRelative(temprect, size);
             d->faceTagsList.insertMulti(faceName, QVariant(faceRect));
         }
     }
 }
 
 QMultiMap<QString, QVariant> Digikam::MetadataHub::getFaceTags()
 {
     return d->faceTagsList;
 }
 
 void Digikam::MetadataHub::setFaceTags(QMultiMap<QString, QVariant> newFaceTags, QSize size)
 {
     d->faceTagsList.clear();
     QMultiMap<QString, QVariant>::iterator it;
 
     for (it = newFaceTags.begin() ; it != newFaceTags.end() ; ++it)
     {
         QRect  temprect = it.value().toRect();
         QRectF faceRect = TagRegion::absoluteToRelative(temprect, size);
         d->faceTagsList.insertMulti(it.key(), faceRect);
     }
 }
 
-void MetadataHub::adjustFaceRectangles(const ItemInfo& info, bool rotatedPixels,
-                                                             int newOrientation,
-                                                             int oldOrientation)
-{
-    /**
-     *  Get all faces from database and rotate them
-     */
-    QList<FaceTagsIface> facesList = FaceTagsEditor().databaseFaces(info.id());
-
-    if (facesList.isEmpty())
-    {
-        return;
-    }
-
-    QSize newSize = info.dimensions();
-    QMultiMap<QString, QRect> adjustedFaces;
-
-    foreach (const FaceTagsIface& dface, facesList)
-    {
-        QRect faceRect = dface.region().toRect();
-        QString name   = FaceTags::faceNameForTag(dface.tagId());
-
-        TagRegion::reverseToOrientation(faceRect,
-                                        oldOrientation,
-                                        info.dimensions());
-
-        newSize = TagRegion::adjustToOrientation(faceRect,
-                                                 newOrientation,
-                                                 info.dimensions());
-
-        if (dface.tagId() == FaceTags::unknownPersonTagId())
-        {
-            name.clear();
-        }
-
-        adjustedFaces.insertMulti(name, faceRect);
-    }
-
-    /**
-     *  Delete all old faces and add rotated ones
-     */
-    FaceTagsEditor().removeAllFaces(info.id());
-
-    QMultiMap<QString, QRect>::ConstIterator it = adjustedFaces.constBegin();
-
-    for ( ; it != adjustedFaces.constEnd() ; ++it)
-    {
-        TagRegion region(it.value());
-
-        if (it.key().isEmpty())
-        {
-            int tagId = FaceTags::unknownPersonTagId();
-            FaceTagsIface face(FaceTagsIface::UnknownName, info.id(), tagId, region);
-
-            FaceTagsEditor().addManually(face);
-        }
-        else
-        {
-            int tagId = FaceTags::getOrCreateTagForPerson(it.key());
-
-            if (!tagId)
-            {
-                qCDebug(DIGIKAM_GENERAL_LOG) << "Failed to create a person tag for name" << it.key();
-            }
-
-            FaceTagsEditor().add(info.id(), tagId, region, false);
-        }
-    }
-
-    /**
-     * Write medatada
-     */
-    load(info);
-
-    // Adjusted newSize
-
-    if (!rotatedPixels)
-    {
-        newSize = info.dimensions();
-    }
-
-    loadFaceTags(info, newSize);
-    write(info.filePath(), MetadataHub::WRITE_ALL, true);
-}
-
 // NOTE: Unused code
 //void MetadataHub::load(const DMetadata& metadata)
 //{
 //    d->count++;
 
 //    CaptionsMap comments;
 //    CaptionsMap titles;
 //    QStringList keywords;
 //    QDateTime   datetime;
 //    int         pickLabel;
 //    int         colorLabel;
 //    int         rating;
 
 //    titles = metadata.getItemTitles();
 
 //    // Try to get comments from image :
 //    // In first, from Xmp comments tag,
 //    // In second, from standard JPEG JFIF comments section,
 //    // In third, from Exif comments tag,
 //    // In four, from Iptc comments tag.
 //    comments = metadata.getItemComments();
 
 //    // Try to get date and time from image :
 //    // In first, from Exif date & time tags,
 //    // In second, from Xmp date & time tags, or
 //    // In third, from Iptc date & time tags.
 //    // else use file system time stamp.
 //    datetime = metadata.getItemDateTime();
 
 //    if ( !datetime.isValid() )
 //    {
 //        QFileInfo info( metadata.getFilePath() );
 //        datetime = info.lastModified();
 //    }
 
 //    // Try to get image pick label from Xmp tag
 //    pickLabel = metadata.getItemPickLabel();
 
 //    // Try to get image color label from Xmp tag
 //    colorLabel = metadata.getItemColorLabel();
 
 //    // Try to get image rating from Xmp tag, or Iptc Urgency tag
 //    rating = metadata.getItemRating();
 
 //    Template tref = metadata.getMetadataTemplate();
 //    Template t    = TemplateManager::defaultManager()->findByContents(tref);
 
 //    qCDebug(DIGIKAM_GENERAL_LOG) << "Found Metadata Template: " << t.templateTitle();
 
 //    load(datetime, titles, comments, colorLabel, pickLabel, rating, t.isNull() ? tref : t);
 
 //    // Try to get image tags from Xmp using digiKam namespace tags.
 
 //    QStringList tagPaths;
 
 //    if (metadata.getItemTagsPath(tagPaths))
 //    {
 //        QList<int> tagIds = TagsCache::instance()->tagsForPaths(tagPaths);
 //        loadTags(tagIds);
 //    }
 //}
 
 //bool MetadataHub::load(const QString& filePath, const MetaEngineSettingsContainer& settings)
 //{
 
 //    DMetadata metadata;
 //    metadata.setSettings(settings);
 //    bool success = metadata.load(filePath);
 //    load(metadata); // increments count
 //    return success;
 //}
 
 /*
 // private code to merge tags with d->tagList
 void MetadataHub::loadTags(const QStringList& loadedTagPaths)
 {
     if (d->count == 1)
     {
         d->tagList = loadedTagPaths;
     }
     else
     {
         // a simple intersection
         QStringList toBeAdded;
         for (QStringList::iterator it = d->tagList.begin(); it != d->tagList.end(); ++it)
         {
             if (loadedTagPaths.indexOf(*it) == -1)
             {
                 // it's not in the loadedTagPaths list. Remove it from intersection list.
                 it = d->tagList.erase(it);
             }
             // else, it is in both lists, so no need to change d->tagList, it's already added.
         }
     }
 }
 */
 
 } // namespace Digikam
diff --git a/core/libs/fileactionmanager/metadatahub.h b/core/libs/fileactionmanager/metadatahub.h
index fc3b18dbc7..46335028e9 100644
--- a/core/libs/fileactionmanager/metadatahub.h
+++ b/core/libs/fileactionmanager/metadatahub.h
@@ -1,294 +1,287 @@
 /* ============================================================
  *
  * This file is a part of digiKam project
  * https://www.digikam.org
  *
  * Date        : 2007-01-05
  * Description : Metadata handling
  *
  * Copyright (C) 2007-2012 by Marcel Wiesweg <marcel dot wiesweg at gmx dot de>
  * Copyright (C) 2007-2020 by Gilles Caulier <caulier dot gilles at gmail dot 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, 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.
  *
  * ============================================================ */
 
 #ifndef DIGIKAM_METADATA_HUB_H
 #define DIGIKAM_METADATA_HUB_H
 
 // Qt includes
 
 #include <QList>
 #include <QStringList>
 #include <QDateTime>
 #include <QMap>
 
 // Local includes
 
 #include "metaenginesettings.h"
 #include "captionvalues.h"
 #include "dmetadata.h"
 #include "dimg.h"
 
 namespace Digikam
 {
 
 class ApplicationSettings;
 class ItemInfo;
 class Template;
 
 class MetadataHub
 {
 public:
 
     /**
      * The status enum describes the result of joining several metadata sets.
      * If only one set has been added, the status is always MetadataAvailable.
      * If no set has been added, the status is always MetadataInvalid
      */
     enum Status
     {
         MetadataInvalid,   ///< not yet filled with any value
         MetadataAvailable  ///< only one data set has been added, or a common value is available
     };
 
     enum WriteMode
     {
         /**
          * Write all available information
          */
         FullWrite,
 
         /**
          * Do a full write if and only if
          *     - metadata fields changed
          *     - the changed fields shall be written according to write settings
          * "Changed" in this context means changed by one of the set... methods,
          * the load() methods are ignored for this attribute.
          * This mode allows to avoid write operations when e.g. the user does not want
          * keywords to be written and only changes keywords.
          */
         FullWriteIfChanged,
 
         /**
          * Write only the changed parts.
          * Metadata fields which cannot be changed from MetadataHub (photographer ID etc.)
          * will never be written
          */
         PartialWrite
     };
 
     enum WriteComponents
     {
         WRITE_DATETIME  = 1,
         WRITE_TITLE     = 2,
         WRITE_COMMENTS  = 4,
         WRITE_PICKLABEL = 8,
         WRITE_COLORLABEL= 16,
         WRITE_RATING    = 32,
         WRITE_TEMPLATE  = 64,
         WRITE_TAGS      = 128,
         WRITE_POSITION  = 256,
         WRITE_ALL       = 511
     };
     Q_DECLARE_FLAGS(WriteComponent, WriteComponents)
 
 public:
 
     /**
      * Constructs a MetadataHub.
      * @param dbmode Determines if the database may be accessed or not. See the enum description above.
      */
     MetadataHub();
     virtual ~MetadataHub();
 
     /// Copies by value - no sharing involved.
     MetadataHub& operator=(const MetadataHub&);
     MetadataHub(const MetadataHub&);
 
     /**
      * Creates a copy (as always, by value) of this hub.
      * Shall be reimplemented by subclasses to return an object of the correct type.
      */
     virtual MetadataHub* clone() const;
 
     void reset();
 
     // --------------------------------------------------
 
     /**
      * Add metadata information contained in the ItemInfo object.
      * This method (or in combination with the other load methods)
      * can be called multiple times on the same MetadataHub object.
      * In this case, the metadata will be combined.
      */
     void load(const ItemInfo& info);
 
 //    /**
 //     * Add metadata information from the DMetadata object
 //     */
 //    void load(const DMetadata& metadata);
 
 //    /**
 //     * Load metadata information from the given file.
 //     * (Uses DMetadata, QFileInfo)
 //     * @returns True if the metadata could be loaded
 //     */
 //    bool load(const QString& filePath, const MetaEngineSettingsContainer& settings = MetaEngineSettings::instance()->settings());
 
     // --------------------------------------------------
 
     /**
      * @brief writeToMetadata - write to metadata using image info to retrieve tags and filepath
      *                          use this method when multiple image infos are loaded in hub
      * @param info - image info to retrieve current tags
      * @param writeMode
      * @param settings
      * @return true           - if everything is successful
      */
     bool writeToMetadata(const ItemInfo& info, WriteComponent writeMode = WRITE_ALL,
                bool ignoreLazySync = false, const MetaEngineSettingsContainer& settings = MetaEngineSettings::instance()->settings());
 
 
     /**
      * Constructs a DMetadata object for given filePath,
      * calls the above method, writes the changes out to the file,
      * and notifies the ItemAttributesWatch.
      * WARNING: Do not use this method when multiple image infos are loaded
      *          It will result in disjoint tags not being written
      *          Use writeToMetadata(Image info ...) instead
      * @return Returns if the file has been touched
      */
     bool write(const QString& filePath, WriteComponent writeMode = WRITE_ALL,
                bool ignoreLazySync = false, const MetaEngineSettingsContainer& settings = MetaEngineSettings::instance()->settings());
 
     /**
      * Constructs a DMetadata object from the metadata stored in the given DImg object,
      * calls the above method, and changes the stored metadata in the DImg object.
      * @return Returns if the DImg object has been touched
      */
     bool write(DImg& image, WriteComponent writeMode = WRITE_ALL,
                bool ignoreLazySync = false, const MetaEngineSettingsContainer& settings = MetaEngineSettings::instance()->settings());
 
     /**
      * Will write only Tags to image. Used by TagsManager to write tags to image
      * Other metadata are not updated.
      * @return if tags were successfully written.
      */
     bool writeTags(const QString& filePath, WriteComponent writeMode = WRITE_ALL,
                    const MetaEngineSettingsContainer& settings = MetaEngineSettings::instance()->settings());
 
     /**
      * @brief writeTags - used to deduplicate code from writeTags and usual write, all write to tags
      *                    operations must be done here
      * @param metadata  - DMetadata object that apply changes
      * @param saveTags  - save switch
      * @return          - if tags were successfully set
      */
     bool writeTags(DMetadata& metadata, bool saveTags);
 
     /**
      * @brief cleanupTags - remove duplicates and obsolete tags before setting metadata
      * @param toClean     - tag list to be cleared and de-duplicated
      * @return            - clean tag list
      */
     QStringList cleanupTags(const QStringList& toClean);
 
     /**
      * With the currently applied changes, the given writeMode and settings,
      * returns if write(DMetadata), write(QString) or write(DImg) will actually
      * apply any changes.
      */
     bool willWriteMetadata(Digikam::MetadataHub::WriteComponent writeMode = WRITE_ALL,
                            const MetaEngineSettingsContainer& settings = MetaEngineSettings::instance()->settings()) const;
 
     /**
      * @brief writeToBaloo - write tags, comments and rating to KDE Nepomuk replacement: Baloo
      * @param filePath     - path to file to add comments, tags and rating
      * @param settings     - metadata settings to be set
      */
     void writeToBaloo(const QString& filePath, const MetaEngineSettingsContainer& settings = MetaEngineSettings::instance()->settings());
 
 
     // --------------------------------------------------
 
     /**
      * Dedicated method to set face rectangles from database
      * When called from outside the metadatahub and  ItemInfo is cached,
      * method dimension() can return wrong values, QSize must be specified
      * manually
      */
     void loadFaceTags(const ItemInfo& info, const QSize& size);
 
     /**
      * Get face tag names and face tag regions.
      * This is used for metadata synchronization in Image Editor
      */
     QMultiMap<QString, QVariant> getFaceTags();
 
     /**
      * Set new face tags
      */
     void setFaceTags(QMultiMap<QString, QVariant> newFaceTags, QSize size);
 
-    /**
-     * Rotate face tags
-     */
-    void adjustFaceRectangles(const ItemInfo& info, bool rotatedPixels,
-                                                    int newOrientation,
-                                                    int oldOrientation);
-
 protected:
 
     /**
      * Applies the set of metadata contained in this MetadataHub
      * to the given DMetadata object.
      * The MetaEngineSettingsContainer determine whether data is actually
      * set or not.
      * The following metadata fields may be set (depending on settings):
      * - Comment
      * - Date
      * - Rating
      * - Tags
      * - Photographer ID (data from settings)
      * - Credits (data from settings)
      *
      * The data fields taken from this MetadataHub object are only set if
      * their status is MetadataAvailable.
      * If the status is MetadataInvalid or MetadataDisjoint, the respective
      * metadata field is not touched.
      * @return Returns true if the metadata object has been touched
      */
     bool write(DMetadata& metadata, WriteComponent writeMode = WRITE_ALL,
                const MetaEngineSettingsContainer& settings = MetaEngineSettings::instance()->settings());
 
     void load(const QDateTime& dateTime,
               const CaptionsMap& titles, const CaptionsMap& comment,
               int colorLabel, int pickLabel,
               int rating, const Template& t);
     void loadTags(const QList<int>& loadedTagIds);
     void loadTags(const QStringList& loadedTagPaths);
     void notifyTagDeleted(int id);
 
     virtual void applyChangeNotifications();
 
 private:
 
     class Private;
     Private* const d;
 };
 
 } // namespace Digikam
 
 Q_DECLARE_OPERATORS_FOR_FLAGS(Digikam::MetadataHub::WriteComponent)
 
 #endif // DIGIKAM_METADATA_HUB_H
diff --git a/core/libs/settings/applicationsettings.cpp b/core/libs/settings/applicationsettings.cpp
index 1d2c867c73..839663e161 100644
--- a/core/libs/settings/applicationsettings.cpp
+++ b/core/libs/settings/applicationsettings.cpp
@@ -1,492 +1,492 @@
 /* ============================================================
  *
  * This file is a part of digiKam project
  * https://www.digikam.org
  *
  * Date        : 2003-16-10
  * Description : application settings interface
  *
  * Copyright (C) 2003-2004 by Renchi Raju <renchi dot raju at gmail dot com>
  * Copyright (C) 2003-2020 by Gilles Caulier <caulier dot gilles at gmail dot com>
  * Copyright (C) 2007      by Arnd Baecker <arnd dot baecker at web dot de>
  * Copyright (C) 2014-2015 by Mohamed_Anwer <m_dot_anwer at gmx dot com>
  * Copyright (C) 2014      by Veaceslav Munteanu <veaceslav dot munteanu90 at gmail dot com>
  * Copyright (C) 2017      by Simon Frei <freisim93 at gmail dot 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, 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.
  *
  * ============================================================ */
 
 #include "applicationsettings_p.h"
 
 namespace Digikam
 {
 
 class Q_DECL_HIDDEN ApplicationSettingsCreator
 {
 public:
 
     ApplicationSettings object;
 };
 
 Q_GLOBAL_STATIC(ApplicationSettingsCreator, creator)
 
 // -------------------------------------------------------------------------------------------------
 
 ApplicationSettings* ApplicationSettings::instance()
 {
     return &creator->object;
 }
 
 ApplicationSettings::ApplicationSettings()
     : QObject(),
       d(new Private(this))
 {
     d->config = KSharedConfig::openConfig();
     d->init();
     readSettings();
 
     // Init Max Thumbnail Size at startup.
 
     ThumbnailSize::readSettings(generalConfigGroup());
 }
 
 ApplicationSettings::~ApplicationSettings()
 {
     delete d;
 }
 
 QString ApplicationSettings::generalConfigGroupName() const
 {
     return d->configGroupGeneral;
 }
 
 KConfigGroup ApplicationSettings::generalConfigGroup() const
 {
     return d->config->group(generalConfigGroupName());
 }
 
 void ApplicationSettings::emitSetupChanged()
 {
     emit setupChanged();
 }
 
 void ApplicationSettings::applyBalooSettings()
 {
 
 #ifdef HAVE_KFILEMETADATA
 
     BalooWrap::instance()->setSyncToBaloo(d->syncToBaloo);
     BalooWrap::instance()->setSyncToDigikam(d->syncToDigikam);
 
 #endif
 
 }
 
 void ApplicationSettings::readSettings()
 {
     KSharedConfigPtr config    = d->config;
 
     // ---------------------------------------------------------------------
 
     KConfigGroup group         = config->group(d->configGroupDefault);
     QStringList collectionList = group.readEntry(d->configAlbumCollectionsEntry, QStringList());
 
     if (!collectionList.isEmpty())
     {
         collectionList.sort();
         d->albumCategoryNames = collectionList;
     }
 
     d->albumSortRole                     = ApplicationSettings::AlbumSortRole(group.readEntry(d->configAlbumSortRoleEntry,
                                                                                                        (int)ApplicationSettings::ByFolder));
 
     d->imageSortOrder                    = group.readEntry(d->configImageSortOrderEntry,               (int)ItemSortSettings::SortByFileName);
     d->imageSorting                      = group.readEntry(d->configImageSortingEntry,                 (int)ItemSortSettings::AscendingOrder);
     d->imageSeparationMode               = group.readEntry(d->configImageSeparationModeEntry,          (int)ItemSortSettings::CategoryByAlbum);
     d->imageSeparationSortOrder          = group.readEntry(d->configImageSeparationSortOrderEntry,     (int)ItemSortSettings::AscendingOrder);
 
     d->itemLeftClickAction               = ApplicationSettings::ItemLeftClickAction(group.readEntry(d->configItemLeftClickActionEntry,
                                                                                                        (int)ApplicationSettings::ShowPreview));
 
     d->thumbnailSize                     = group.readEntry(d->configDefaultIconSizeEntry,              (int)ThumbnailSize::Medium);
     d->treeThumbnailSize                 = group.readEntry(d->configDefaultTreeIconSizeEntry,          22);
     d->treeviewFont                      = group.readEntry(d->configTreeViewFontEntry,                 QFontDatabase::systemFont(QFontDatabase::GeneralFont));
     d->currentTheme                      = group.readEntry(d->configThemeEntry,                        ThemeManager::instance()->defaultThemeName());
 
     d->sidebarTitleStyle                 = (DMultiTabBar::TextStyle)group.readEntry(d->configSidebarTitleStyleEntry,
                                                                                                        (int)DMultiTabBar::AllIconsText);
 
     d->ratingFilterCond                  = group.readEntry(d->configRatingFilterConditionEntry,
                                                                                                        (int)ItemFilterSettings::GreaterEqualCondition);
 
     d->albumMonitoring                   = group.readEntry(d->configAlbumMonitoringEntry,              false);
     d->recursiveAlbums                   = group.readEntry(d->configRecursiveAlbumsEntry,              false);
     d->recursiveTags                     = group.readEntry(d->configRecursiveTagsEntry,                true);
     d->allGroupsOpen                     = group.readEntry(d->configAllGroupsOpenEntry,                false);
 
     d->iconShowName                      = group.readEntry(d->configIconShowNameEntry,                 false);
     d->iconShowResolution                = group.readEntry(d->configIconShowResolutionEntry,           false);
     d->iconShowAspectRatio               = group.readEntry(d->configIconShowAspectRatioEntry,          false);
     d->iconShowSize                      = group.readEntry(d->configIconShowSizeEntry,                 false);
     d->iconShowDate                      = group.readEntry(d->configIconShowDateEntry,                 false);
     d->iconShowModDate                   = group.readEntry(d->configIconShowModificationDateEntry,     false);
     d->iconShowTitle                     = group.readEntry(d->configIconShowTitleEntry,                true);
     d->iconShowComments                  = group.readEntry(d->configIconShowCommentsEntry,             true);
     d->iconShowTags                      = group.readEntry(d->configIconShowTagsEntry,                 true);
     d->iconShowOverlays                  = group.readEntry(d->configIconShowOverlaysEntry,             true);
     d->iconShowFullscreen                = group.readEntry(d->configIconShowFullscreenEntry,           true);
     d->iconShowRating                    = group.readEntry(d->configIconShowRatingEntry,               true);
     d->iconShowImageFormat               = group.readEntry(d->configIconShowImageFormatEntry,          true);
     d->iconShowCoordinates               = group.readEntry(d->configIconShowCoordinatesEntry,          true);
     d->iconviewFont                      = group.readEntry(d->configIconViewFontEntry,                 QFontDatabase::systemFont(QFontDatabase::GeneralFont));
 
     d->toolTipsFont                      = group.readEntry(d->configToolTipsFontEntry,                 QFontDatabase::systemFont(QFontDatabase::GeneralFont));
     d->showToolTips                      = group.readEntry(d->configShowToolTipsEntry,                 false);
     d->tooltipShowFileName               = group.readEntry(d->configToolTipsShowFileNameEntry,         true);
     d->tooltipShowFileDate               = group.readEntry(d->configToolTipsShowFileDateEntry,         false);
     d->tooltipShowFileSize               = group.readEntry(d->configToolTipsShowFileSizeEntry,         false);
     d->tooltipShowImageType              = group.readEntry(d->configToolTipsShowImageTypeEntry,        false);
     d->tooltipShowImageDim               = group.readEntry(d->configToolTipsShowImageDimEntry,         true);
     d->tooltipShowImageAR                = group.readEntry(d->configToolTipsShowImageAREntry,          true);
     d->tooltipShowPhotoMake              = group.readEntry(d->configToolTipsShowPhotoMakeEntry,        true);
     d->tooltipShowPhotoLens              = group.readEntry(d->configToolTipsShowPhotoLensEntry,        true);
     d->tooltipShowPhotoDate              = group.readEntry(d->configToolTipsShowPhotoDateEntry,        true);
     d->tooltipShowPhotoFocal             = group.readEntry(d->configToolTipsShowPhotoFocalEntry,       true);
     d->tooltipShowPhotoExpo              = group.readEntry(d->configToolTipsShowPhotoExpoEntry,        true);
     d->tooltipShowPhotoMode              = group.readEntry(d->configToolTipsShowPhotoModeEntry,        true);
     d->tooltipShowPhotoFlash             = group.readEntry(d->configToolTipsShowPhotoFlashEntry,       false);
     d->tooltipShowPhotoWb                = group.readEntry(d->configToolTipsShowPhotoWBEntry,          false);
     d->tooltipShowAlbumName              = group.readEntry(d->configToolTipsShowAlbumNameEntry,        false);
     d->tooltipShowTitles                 = group.readEntry(d->configToolTipsShowTitlesEntry,           true);
     d->tooltipShowComments               = group.readEntry(d->configToolTipsShowCommentsEntry,         true);
     d->tooltipShowTags                   = group.readEntry(d->configToolTipsShowTagsEntry,             true);
     d->tooltipShowLabelRating            = group.readEntry(d->configToolTipsShowLabelRatingEntry,      true);
 
     d->tooltipShowVideoAspectRatio       = group.readEntry(d->configToolTipsShowVideoAspectRatioEntry,      true);
     d->tooltipShowVideoAudioBitRate      = group.readEntry(d->configToolTipsShowVideoAudioBitRateEntry,     true);
     d->tooltipShowVideoAudioChannelType  = group.readEntry(d->configToolTipsShowVideoAudioChannelTypeEntry, true);
     d->tooltipShowVideoAudioCodec        = group.readEntry(d->configToolTipsShowVideoAudioCodecEntry,       true);
     d->tooltipShowVideoDuration          = group.readEntry(d->configToolTipsShowVideoDurationEntry,         true);
     d->tooltipShowVideoFrameRate         = group.readEntry(d->configToolTipsShowVideoFrameRateEntry,        true);
     d->tooltipShowVideoVideoCodec        = group.readEntry(d->configToolTipsShowVideoVideoCodecEntry,       true);
 
     d->showAlbumToolTips                 = group.readEntry(d->configShowAlbumToolTipsEntry,            false);
     d->tooltipShowAlbumTitle             = group.readEntry(d->configToolTipsShowAlbumTitleEntry,       true);
     d->tooltipShowAlbumDate              = group.readEntry(d->configToolTipsShowAlbumDateEntry,        true);
     d->tooltipShowAlbumCollection        = group.readEntry(d->configToolTipsShowAlbumCollectionEntry,  true);
     d->tooltipShowAlbumCategory          = group.readEntry(d->configToolTipsShowAlbumCategoryEntry,    true);
     d->tooltipShowAlbumCaption           = group.readEntry(d->configToolTipsShowAlbumCaptionEntry,     true);
     d->tooltipShowAlbumPreview           = group.readEntry(d->configToolTipsShowAlbumPreviewEntry,     false);
 
     if (group.readEntry(d->configPreviewLoadFullItemSizeEntry, true))
     {
         d->previewSettings.quality = PreviewSettings::HighQualityPreview;
         if (group.readEntry(d->configPreviewRawUseEmbeddedPreview, false))
         {
             d->previewSettings.rawLoading = PreviewSettings::RawPreviewFromEmbeddedPreview;
         }
         else if (group.readEntry(d->configPreviewRawUseHalfSizeData, false))
         {
             d->previewSettings.rawLoading = PreviewSettings::RawPreviewFromRawHalfSize;
         }
         else
         {
             d->previewSettings.rawLoading = PreviewSettings::RawPreviewAutomatic;
         }
     }
     else
     {
         d->previewSettings.quality = PreviewSettings::FastPreview;
     }
 
     d->previewSettings.convertToEightBit = group.readEntry(d->configPreviewConvertToEightBitEntry,     true);
     d->previewShowIcons                  = group.readEntry(d->configPreviewShowIconsEntry,             true);
     d->showThumbbar                      = group.readEntry(d->configShowThumbbarEntry,                 true);
 
     d->showFolderTreeViewItemsCount      = group.readEntry(d->configShowFolderTreeViewItemsCountEntry, false);
 
     // ---------------------------------------------------------------------
 
     group                                = generalConfigGroup();
 
     d->showSplash                        = group.readEntry(d->configShowSplashEntry,                                  true);
     d->useTrash                          = group.readEntry(d->configUseTrashEntry,                                    true);
     d->showTrashDeleteDialog             = group.readEntry(d->configShowTrashDeleteDialogEntry,                       true);
     d->showPermanentDeleteDialog         = group.readEntry(d->configShowPermanentDeleteDialogEntry,                   true);
     d->sidebarApplyDirectly              = group.readEntry(d->configApplySidebarChangesDirectlyEntry,                 false);
 
 #ifdef Q_OS_OSX
     d->useNativeFileDialog               = group.readEntry(d->configUseNativeFileDialogEntry,                         true);
 #else
     d->useNativeFileDialog               = group.readEntry(d->configUseNativeFileDialogEntry,                         false);
 #endif
 
     d->drawFramesToGrouped               = group.readEntry(d->configDrawFramesToGroupedEntry,                         true);
     d->scrollItemToCenter                = group.readEntry(d->configScrollItemToCenterEntry,                          false);
     d->showOnlyPersonTagsInPeopleSidebar = group.readEntry(d->configShowOnlyPersonTagsInPeopleSidebarEntry,           true);
     d->stringComparisonType              = (StringComparisonType) group.readEntry(d->configStringComparisonTypeEntry, (int) Natural);
 
 #ifdef HAVE_APPSTYLE_SUPPORT
     QString applicationStyle             = qApp->style()->objectName();
 
     if (applicationStyle.compare(QLatin1String("windowsvista"), Qt::CaseInsensitive) == 0)
     {
         applicationStyle                 = QLatin1String("Windows");
     }
 
     setApplicationStyle(group.readEntry(d->configApplicationStyleEntry, applicationStyle));
 #else
     setApplicationStyle(QLatin1String("Fusion"));
 #endif
 
     d->applicationIcon                   = group.readEntry(d->configIconThemeEntry,                                   QString());
 
     setApplicationFont(group.readEntry(d->configApplicationFontEntry, QFontDatabase::systemFont(QFontDatabase::GeneralFont)));
 
     d->scanAtStart                       = group.readEntry(d->configScanAtStartEntry,                                 true);
     d->cleanAtStart                      = group.readEntry(d->configCleanAtStartEntry,                                false);
 
     // ---------------------------------------------------------------------
 
     d->databaseParams.readFromConfig();
 
 #ifdef HAVE_KFILEMETADATA
 
     group                                = config->group(d->configGroupBaloo);
 
     d->syncToDigikam                     = group.readEntry(d->configSyncBalootoDigikamEntry, false);
     d->syncToBaloo                       = group.readEntry(d->configSyncDigikamtoBalooEntry, false);
 
     emit balooSettingsChanged();
 
 #endif // HAVE_KFILEMETADATA
 
     // ---------------------------------------------------------------------
 
     group = config->group(d->configGroupVersioning);
     d->versionSettings.readFromConfig(group);
 
     // ---------------------------------------------------------------------
 
     group                    = config->group(d->configGroupFaceDetection);
     d->faceDetectionAccuracy = group.readEntry(d->configFaceDetectionAccuracyEntry, double(0.7));
 
     // ---------------------------------------------------------------------
 
     group                    = config->group(d->configGroupDuplicatesSearch);
 
     d->minimumSimilarityBound                = group.readEntry(d->configMinimumSimilarityBound,               40);
     d->duplicatesSearchLastMinSimilarity     = group.readEntry(d->configDuplicatesSearchLastMinSimilarity,    90);
     d->duplicatesSearchLastMaxSimilarity     = group.readEntry(d->configDuplicatesSearchLastMaxSimilarity,    100);
     d->duplicatesSearchLastAlbumTagRelation  = group.readEntry(d->configDuplicatesSearchLastAlbumTagRelation, 0);
     d->duplicatesSearchLastRestrictions      = group.readEntry(d->configDuplicatesSearchLastRestrictions,     0);
 
     // ---------------------------------------------------------------------
 
     group = config->group(d->configGroupGrouping);
 
     for (ApplicationSettings::OperationModes::key_iterator it = d->groupingOperateOnAll.keyBegin();
          it != d->groupingOperateOnAll.keyEnd(); ++it)
     {
         d->groupingOperateOnAll.insert(*it, (ApplicationSettings::ApplyToEntireGroup)group.readEntry(
                                              d->configGroupingOperateOnAll.value(*it), (int)ApplicationSettings::Ask));
     }
 
     emit setupChanged();
     emit recurseSettingsChanged();
     emit balooSettingsChanged();
 }
 
 void ApplicationSettings::saveSettings()
 {
     KSharedConfigPtr config = d->config;
 
     // ---------------------------------------------------------------------
 
     KConfigGroup group = config->group(d->configGroupDefault);
 
     group.writeEntry(d->configAlbumCollectionsEntry,                   d->albumCategoryNames);
     group.writeEntry(d->configAlbumSortRoleEntry,                      (int)d->albumSortRole);
     group.writeEntry(d->configImageSortOrderEntry,                     (int)d->imageSortOrder);
     group.writeEntry(d->configImageSortingEntry,                       (int)d->imageSorting);
     group.writeEntry(d->configImageSeparationModeEntry,                (int)d->imageSeparationMode);
     group.writeEntry(d->configImageSeparationSortOrderEntry,           (int)d->imageSeparationSortOrder);
 
     group.writeEntry(d->configItemLeftClickActionEntry,                (int)d->itemLeftClickAction);
-    group.writeEntry(d->configDefaultIconSizeEntry,                    QString::number(d->thumbnailSize));
-    group.writeEntry(d->configDefaultTreeIconSizeEntry,                QString::number(d->treeThumbnailSize));
+    group.writeEntry(d->configDefaultIconSizeEntry,                    (int)d->thumbnailSize);
+    group.writeEntry(d->configDefaultTreeIconSizeEntry,                (int)d->treeThumbnailSize);
     group.writeEntry(d->configTreeViewFontEntry,                       d->treeviewFont);
     group.writeEntry(d->configRatingFilterConditionEntry,              d->ratingFilterCond);
     group.writeEntry(d->configAlbumMonitoringEntry,                    d->albumMonitoring);
     group.writeEntry(d->configRecursiveAlbumsEntry,                    d->recursiveAlbums);
     group.writeEntry(d->configRecursiveTagsEntry,                      d->recursiveTags);
     group.writeEntry(d->configAllGroupsOpenEntry,                      d->allGroupsOpen);
     group.writeEntry(d->configThemeEntry,                              d->currentTheme);
     group.writeEntry(d->configSidebarTitleStyleEntry,                  (int)d->sidebarTitleStyle);
 
     group.writeEntry(d->configIconShowNameEntry,                       d->iconShowName);
     group.writeEntry(d->configIconShowResolutionEntry,                 d->iconShowResolution);
     group.writeEntry(d->configIconShowAspectRatioEntry,                d->iconShowAspectRatio);
     group.writeEntry(d->configIconShowSizeEntry,                       d->iconShowSize);
     group.writeEntry(d->configIconShowDateEntry,                       d->iconShowDate);
     group.writeEntry(d->configIconShowModificationDateEntry,           d->iconShowModDate);
     group.writeEntry(d->configIconShowTitleEntry,                      d->iconShowTitle);
     group.writeEntry(d->configIconShowCommentsEntry,                   d->iconShowComments);
     group.writeEntry(d->configIconShowTagsEntry,                       d->iconShowTags);
     group.writeEntry(d->configIconShowOverlaysEntry,                   d->iconShowOverlays);
     group.writeEntry(d->configIconShowFullscreenEntry,                 d->iconShowFullscreen);
     group.writeEntry(d->configIconShowRatingEntry,                     d->iconShowRating);
     group.writeEntry(d->configIconShowImageFormatEntry,                d->iconShowImageFormat);
     group.writeEntry(d->configIconShowCoordinatesEntry,                d->iconShowCoordinates);
     group.writeEntry(d->configIconViewFontEntry,                       d->iconviewFont);
 
     group.writeEntry(d->configToolTipsFontEntry,                       d->toolTipsFont);
     group.writeEntry(d->configShowToolTipsEntry,                       d->showToolTips);
     group.writeEntry(d->configToolTipsShowFileNameEntry,               d->tooltipShowFileName);
     group.writeEntry(d->configToolTipsShowFileDateEntry,               d->tooltipShowFileDate);
     group.writeEntry(d->configToolTipsShowFileSizeEntry,               d->tooltipShowFileSize);
     group.writeEntry(d->configToolTipsShowImageTypeEntry,              d->tooltipShowImageType);
     group.writeEntry(d->configToolTipsShowImageDimEntry,               d->tooltipShowImageDim);
     group.writeEntry(d->configToolTipsShowImageAREntry,                d->tooltipShowImageAR);
     group.writeEntry(d->configToolTipsShowPhotoMakeEntry,              d->tooltipShowPhotoMake);
     group.writeEntry(d->configToolTipsShowPhotoLensEntry,              d->tooltipShowPhotoLens);
     group.writeEntry(d->configToolTipsShowPhotoDateEntry,              d->tooltipShowPhotoDate);
     group.writeEntry(d->configToolTipsShowPhotoFocalEntry,             d->tooltipShowPhotoFocal);
     group.writeEntry(d->configToolTipsShowPhotoExpoEntry,              d->tooltipShowPhotoExpo);
     group.writeEntry(d->configToolTipsShowPhotoModeEntry,              d->tooltipShowPhotoMode);
     group.writeEntry(d->configToolTipsShowPhotoFlashEntry,             d->tooltipShowPhotoFlash);
     group.writeEntry(d->configToolTipsShowPhotoWBEntry,                d->tooltipShowPhotoWb);
     group.writeEntry(d->configToolTipsShowAlbumNameEntry,              d->tooltipShowAlbumName);
     group.writeEntry(d->configToolTipsShowTitlesEntry,                 d->tooltipShowTitles);
     group.writeEntry(d->configToolTipsShowCommentsEntry,               d->tooltipShowComments);
     group.writeEntry(d->configToolTipsShowTagsEntry,                   d->tooltipShowTags);
     group.writeEntry(d->configToolTipsShowLabelRatingEntry,            d->tooltipShowLabelRating);
 
     group.writeEntry(d->configToolTipsShowVideoAspectRatioEntry,       d->tooltipShowVideoAspectRatio);
     group.writeEntry(d->configToolTipsShowVideoAudioBitRateEntry,      d->tooltipShowVideoAudioBitRate);
     group.writeEntry(d->configToolTipsShowVideoAudioChannelTypeEntry,  d->tooltipShowVideoAudioChannelType);
     group.writeEntry(d->configToolTipsShowVideoAudioCodecEntry,        d->tooltipShowVideoAudioCodec);
     group.writeEntry(d->configToolTipsShowVideoDurationEntry,          d->tooltipShowVideoDuration);
     group.writeEntry(d->configToolTipsShowVideoFrameRateEntry,         d->tooltipShowVideoFrameRate);
     group.writeEntry(d->configToolTipsShowVideoVideoCodecEntry,        d->tooltipShowVideoVideoCodec);
 
     group.writeEntry(d->configShowAlbumToolTipsEntry,                  d->showAlbumToolTips);
     group.writeEntry(d->configToolTipsShowAlbumTitleEntry,             d->tooltipShowAlbumTitle);
     group.writeEntry(d->configToolTipsShowAlbumDateEntry,              d->tooltipShowAlbumDate);
     group.writeEntry(d->configToolTipsShowAlbumCollectionEntry,        d->tooltipShowAlbumCollection);
     group.writeEntry(d->configToolTipsShowAlbumCategoryEntry,          d->tooltipShowAlbumCategory);
     group.writeEntry(d->configToolTipsShowAlbumCaptionEntry,           d->tooltipShowAlbumCaption);
     group.writeEntry(d->configToolTipsShowAlbumPreviewEntry,           d->tooltipShowAlbumPreview);
 
     if (d->previewSettings.quality == PreviewSettings::HighQualityPreview)
     {
         group.writeEntry(d->configPreviewLoadFullItemSizeEntry, true);
 
         switch (d->previewSettings.rawLoading)
         {
             case PreviewSettings::RawPreviewAutomatic:
                 group.writeEntry(d->configPreviewRawUseEmbeddedPreview, false);
                 group.writeEntry(d->configPreviewRawUseHalfSizeData,    false);
                 break;
             case PreviewSettings::RawPreviewFromEmbeddedPreview:
                 group.writeEntry(d->configPreviewRawUseEmbeddedPreview, true);
                 group.writeEntry(d->configPreviewRawUseHalfSizeData,    false);
                 break;
             case PreviewSettings::RawPreviewFromRawHalfSize:
                 group.writeEntry(d->configPreviewRawUseEmbeddedPreview, false);
                 group.writeEntry(d->configPreviewRawUseHalfSizeData,    true);
                 break;
         }
     }
     else
     {
         group.writeEntry(d->configPreviewLoadFullItemSizeEntry, false);
     }
 
     group.writeEntry(d->configPreviewConvertToEightBitEntry,           d->previewSettings.convertToEightBit);
     group.writeEntry(d->configPreviewShowIconsEntry,                   d->previewShowIcons);
     group.writeEntry(d->configShowThumbbarEntry,                       d->showThumbbar);
     group.writeEntry(d->configShowFolderTreeViewItemsCountEntry,       d->showFolderTreeViewItemsCount);
 
     // ---------------------------------------------------------------------
 
     group = generalConfigGroup();
 
     group.writeEntry(d->configShowSplashEntry,                         d->showSplash);
     group.writeEntry(d->configUseTrashEntry,                           d->useTrash);
     group.writeEntry(d->configShowTrashDeleteDialogEntry,              d->showTrashDeleteDialog);
     group.writeEntry(d->configShowPermanentDeleteDialogEntry,          d->showPermanentDeleteDialog);
     group.writeEntry(d->configApplySidebarChangesDirectlyEntry,        d->sidebarApplyDirectly);
     group.writeEntry(d->configUseNativeFileDialogEntry,                d->useNativeFileDialog);
     group.writeEntry(d->configDrawFramesToGroupedEntry,                d->drawFramesToGrouped);
     group.writeEntry(d->configScrollItemToCenterEntry,                 d->scrollItemToCenter);
     group.writeEntry(d->configShowOnlyPersonTagsInPeopleSidebarEntry,  d->showOnlyPersonTagsInPeopleSidebar);
     group.writeEntry(d->configStringComparisonTypeEntry,               (int) d->stringComparisonType);
 
 #ifdef HAVE_APPSTYLE_SUPPORT
 
     group.writeEntry(d->configApplicationStyleEntry,                   d->applicationStyle);
 
 #endif
 
     group.writeEntry(d->configIconThemeEntry,                          d->applicationIcon);
     group.writeEntry(d->configApplicationFontEntry,                    d->applicationFont);
 
     group.writeEntry(d->configScanAtStartEntry,                        d->scanAtStart);
     group.writeEntry(d->configCleanAtStartEntry,                       d->cleanAtStart);
 
     // ---------------------------------------------------------------------
 
     d->databaseParams.writeToConfig();
 
 #ifdef HAVE_KFILEMETADATA
 
     group = config->group(d->configGroupBaloo);
 
     group.writeEntry(d->configSyncBalootoDigikamEntry,                 d->syncToDigikam);
     group.writeEntry(d->configSyncDigikamtoBalooEntry,                 d->syncToBaloo);
 
 #endif // HAVE_KFILEMETADATA
 
     // ---------------------------------------------------------------------
 
     group = config->group(d->configGroupVersioning);
     d->versionSettings.writeToConfig(group);
 
     // ---------------------------------------------------------------------
 
     group = config->group(d->configGroupFaceDetection);
 
     group.writeEntry(d->configFaceDetectionAccuracyEntry,              d->faceDetectionAccuracy);
 
     group = config->group(d->configGroupDuplicatesSearch);
 
     group.writeEntry(d->configMinimumSimilarityBound,                  d->minimumSimilarityBound);
     group.writeEntry(d->configDuplicatesSearchLastMinSimilarity,       d->duplicatesSearchLastMinSimilarity);
     group.writeEntry(d->configDuplicatesSearchLastMaxSimilarity,       d->duplicatesSearchLastMaxSimilarity);
     group.writeEntry(d->configDuplicatesSearchLastAlbumTagRelation,    d->duplicatesSearchLastAlbumTagRelation);
     group.writeEntry(d->configDuplicatesSearchLastRestrictions,        d->duplicatesSearchLastRestrictions);
 
     group = config->group(d->configGroupGrouping);
 
     for (ApplicationSettings::OperationModes::key_iterator it = d->groupingOperateOnAll.keyBegin() ;
          it != d->groupingOperateOnAll.keyEnd() ; ++it)
     {
         group.writeEntry(d->configGroupingOperateOnAll.value(*it),
                          (int)d->groupingOperateOnAll.value(*it));
     }
 
     config->sync();
 }
 
 } // namespace Digikam
diff --git a/core/utilities/facemanagement/database/faceutils.cpp b/core/utilities/facemanagement/database/faceutils.cpp
index aab7bd3e73..46cf0f6912 100644
--- a/core/utilities/facemanagement/database/faceutils.cpp
+++ b/core/utilities/facemanagement/database/faceutils.cpp
@@ -1,341 +1,412 @@
 /* ============================================================
  *
  * This file is a part of digiKam project
  * https://www.digikam.org
  *
  * Date        : 2010-08-08
  * Description : FaceEngine database interface allowing easy manipulation of face tags
  *
  * Copyright (C) 2010-2011 by Aditya Bhatt <adityabhatt1991 at gmail dot com>
  * Copyright (C) 2010-2011 by Marcel Wiesweg <marcel dot wiesweg at gmx dot de>
  * Copyright (C) 2012-2020 by Gilles Caulier <caulier dot gilles at gmail dot 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, 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.
  *
  * ============================================================ */
 
 #include "faceutils.h"
 
 // Qt includes
 
 #include <QImage>
 
 // Local includes
 
 #include "digikam_debug.h"
 #include "coredbaccess.h"
 #include "coredbconstants.h"
 #include "coredboperationgroup.h"
 #include "dimg.h"
 #include "facetags.h"
 #include "iteminfo.h"
 #include "itemtagpair.h"
 #include "fileactionmngr.h"
 #include "tagproperties.h"
 #include "tagscache.h"
 #include "tagregion.h"
 #include "thumbnailloadthread.h"
 
 namespace Digikam
 {
 
 // --- Constructor / Destructor -------------------------------------------------------------------------------------
 
 FaceUtils::FaceUtils()
 {
 }
 
 FaceUtils::~FaceUtils()
 {
 }
 
 // --- Mark for scanning and training -------------------------------------------------------------------------------
 
 bool FaceUtils::hasBeenScanned(qlonglong imageid) const
 {
     return hasBeenScanned(ItemInfo(imageid));
 }
 
 bool FaceUtils::hasBeenScanned(const ItemInfo& info) const
 {
     return info.tagIds().contains(FaceTags::scannedForFacesTagId());
 }
 
 void FaceUtils::markAsScanned(qlonglong imageid, bool hasBeenScanned) const
 {
     return markAsScanned(ItemInfo(imageid), hasBeenScanned);
 }
 
 void FaceUtils::markAsScanned(const ItemInfo& info, bool hasBeenScanned) const
 {
     if (hasBeenScanned)
     {
         ItemInfo(info).setTag(FaceTags::scannedForFacesTagId());
     }
     else
     {
         ItemInfo(info).removeTag(FaceTags::scannedForFacesTagId());
     }
 }
 
 // --- Convert between FacesEngine results and FaceTagsIface ---
 
 QList<FaceTagsIface> FaceUtils::toFaceTagsIfaces(qlonglong imageid,
                                                  const QList<QRectF>& detectedFaces,
                                                  const QList<Identity> recognitionResults,
                                                  const QSize& fullSize) const
 {
     QList<FaceTagsIface> faces;
 
     for (int i = 0 ; i < detectedFaces.size() ; ++i)
     {
         Identity identity;
 
         if (!recognitionResults.isEmpty())
         {
             identity = recognitionResults[i];
         }
 
         // We'll get the unknownPersonTagId if the identity is null
 
         int tagId                = FaceTags::getOrCreateTagForIdentity(identity.attributesMap());
         QRect fullSizeRect       = TagRegion::relativeToAbsolute(detectedFaces[i], fullSize);
         FaceTagsIface::Type type = identity.isNull() ? FaceTagsIface::UnknownName : FaceTagsIface::UnconfirmedName;
 
         if (!tagId || !fullSizeRect.isValid())
         {
             faces << FaceTagsIface();
             continue;
         }
 /*
         qCDebug(DIGIKAM_GENERAL_LOG) << "New Entry" << fullSizeRect << tagId;
 */
         faces << FaceTagsIface(type, imageid, tagId, TagRegion(fullSizeRect));
     }
 
     return faces;
 }
 
 // --- Images in faces and thumbnails ---
 
 void FaceUtils::storeThumbnails(ThumbnailLoadThread* const thread,
                                 const QString& filePath,
                                 const QList<FaceTagsIface>& databaseFaces,
                                 const DImg& image)
 {
     foreach (const FaceTagsIface& face, databaseFaces)
     {
         QList<QRect> rects;
         rects << face.region().toRect();
         const int margin = faceRectDisplayMargin(face.region().toRect());
         rects << face.region().toRect().adjusted(-margin, -margin, margin, margin);
 
         foreach (const QRect& rect, rects)
         {
             QRect mapped  = TagRegion::mapFromOriginalSize(image, rect);
             QImage detail = image.copyQImage(mapped);
             thread->storeDetailThumbnail(filePath, rect, detail, true);
         }
     }
 }
 
 // --- Face detection: merging results ------------------------------------------------------------------------------------
 
 QList<FaceTagsIface> FaceUtils::writeUnconfirmedResults(qlonglong imageid,
                                                         const QList<QRectF>& detectedFaces,
                                                         const QList<Identity> recognitionResults,
                                                         const QSize& fullSize)
 {
     // Build list of new entries
 
     QList<FaceTagsIface> newFaces = toFaceTagsIfaces(imageid, detectedFaces, recognitionResults, fullSize);
 
     if (newFaces.isEmpty())
     {
         return newFaces;
     }
 
     // list of existing entries
 
     QList<FaceTagsIface> currentFaces = databaseFaces(imageid);
 
     // merge new with existing entries
 
     for (int i = 0 ; i < newFaces.size() ; ++i)
     {
         FaceTagsIface& newFace = newFaces[i];
         QList<FaceTagsIface> overlappingEntries;
 
         foreach (const FaceTagsIface& oldFace, currentFaces)
         {
             double minOverlap = oldFace.isConfirmedName() ? 0.25 : 0.5;
 
             if (oldFace.region().intersects(newFace.region(), minOverlap))
             {
                 overlappingEntries << oldFace;
                 qCDebug(DIGIKAM_GENERAL_LOG) << "Entry" << oldFace.region() << oldFace.tagId()
                                              << "overlaps" << newFace.region() << newFace.tagId() << ", skipping";
             }
         }
 
         // The purpose if the next scope is to merge entries:
         // A confirmed face will never be overwritten.
         // If a name is set to an old face, it will only be replaced by a new face with a name.
 
         if (!overlappingEntries.isEmpty())
         {
             if (newFace.isUnknownName())
             {
                 // we have no name in the new face. Do we have one in the old faces?
 
                 for (int j = 0 ; j < overlappingEntries.size() ; ++j)
                 {
                     const FaceTagsIface& oldFace = overlappingEntries.at(j);
 
                     if (oldFace.isUnknownName())
                     {
                         // remove old face
                     }
                     else
                     {
                         // skip new entry if any overlapping face has a name, and we do not
 
                         newFace = FaceTagsIface();
                         break;
                     }
                 }
             }
             else
             {
                 // we have a name in the new face. Do we have names in overlapping faces?
 
                 for (int j = 0 ; j < overlappingEntries.size() ; ++j)
                 {
                     FaceTagsIface& oldFace = overlappingEntries[j];
 
                     if (oldFace.isUnknownName())
                     {
                         // remove old face
                     }
                     else if (oldFace.isUnconfirmedName())
                     {
                         if (oldFace.tagId() == newFace.tagId())
                         {
                             // remove smaller face
 
                             if (oldFace.region().intersects(newFace.region(), 1))
                             {
                                 newFace = FaceTagsIface();
                                 break;
                             }
 
                             // else remove old face
                         }
                         else
                         {
                             // assume new recognition is more trained, remove older face
                         }
                     }
                     else if (oldFace.isConfirmedName())
                     {
                         // skip new entry, confirmed has of course priority
 
                         newFace = FaceTagsIface();
                     }
                 }
             }
         }
 
         // if we did not decide to skip this face, add is to the db now
 
         if (!newFace.isNull())
         {
             // list will contain all old entries that should still be removed
 
             removeFaces(overlappingEntries);
 
             ItemTagPair pair(imageid, newFace.tagId());
 
             // UnconfirmedName and UnknownName have the same attribute
 
             addFaceAndTag(pair, newFace, FaceTagsIface::attributesForFlags(FaceTagsIface::UnconfirmedName), false);
 
             // If the face is unconfirmed and the tag is not the unknown person tag, set the unconfirmed person property.
 
             if (newFace.isUnconfirmedType() && !FaceTags::isTheUnknownPerson(newFace.tagId()))
             {
                 ItemTagPair unconfirmedPair(imageid, FaceTags::unconfirmedPersonTagId());
                 unconfirmedPair.addProperty(ImageTagPropertyName::autodetectedPerson(),newFace.getAutodetectedPersonString());
             }
         }
     }
 
     return newFaces;
 }
 
 Identity FaceUtils::identityForTag(int tagId, RecognitionDatabase& db) const
 {
     QMap<QString, QString> attributes = FaceTags::identityAttributes(tagId);
     Identity identity                 = db.findIdentity(attributes);
 
     if (!identity.isNull())
     {
         qCDebug(DIGIKAM_GENERAL_LOG) << "Found FacesEngine identity" << identity.id() << "for tag" << tagId;
         return identity;
     }
 
     qCDebug(DIGIKAM_GENERAL_LOG) << "Adding new FacesEngine identity with attributes" << attributes;
     identity                          = db.addIdentity(attributes);
 
     FaceTags::applyTagIdentityMapping(tagId, identity.attributesMap());
 
     return identity;
 }
 
 int FaceUtils::tagForIdentity(const Identity& identity) const
 {
     return FaceTags::getOrCreateTagForIdentity(identity.attributesMap());
 }
 
 // --- Editing normal tags, reimplemented with FileActionMngr ---
 
 void FaceUtils::addNormalTag(qlonglong imageid, int tagId)
 {
     FileActionMngr::instance()->assignTag(ItemInfo(imageid), tagId);
 }
 
 void FaceUtils::removeNormalTag(qlonglong imageId, int tagId)
 {
     FileActionMngr::instance()->removeTag(ItemInfo(imageId), tagId);
 }
 
 void FaceUtils::removeNormalTags(qlonglong imageId, QList<int> tagIds)
 {
     FileActionMngr::instance()->removeTags(ItemInfo(imageId), tagIds);
 }
 
 // --- Utilities ---
 
+QSize FaceUtils::rotateFaces(const ItemInfo& info, int newOrientation,
+                                                   int oldOrientation)
+{
+    /**
+     *  Get all faces from database and rotate them
+     */
+    QList<FaceTagsIface> facesList = databaseFaces(info.id());
+
+    if (facesList.isEmpty())
+    {
+        return QSize();
+    }
+
+    QSize newSize = info.dimensions();
+    QMultiMap<QString, QRect> adjustedFaces;
+
+    foreach (const FaceTagsIface& dface, facesList)
+    {
+        QRect faceRect = dface.region().toRect();
+        QString name   = FaceTags::faceNameForTag(dface.tagId());
+
+        TagRegion::reverseToOrientation(faceRect,
+                                        oldOrientation,
+                                        info.dimensions());
+
+        newSize = TagRegion::adjustToOrientation(faceRect,
+                                                 newOrientation,
+                                                 info.dimensions());
+
+        if (dface.tagId() == FaceTags::unknownPersonTagId())
+        {
+            name.clear();
+        }
+
+        adjustedFaces.insertMulti(name, faceRect);
+    }
+
+    /**
+     *  Delete all old faces and add rotated ones
+     */
+    FaceTagsEditor().removeAllFaces(info.id());
+
+    QMultiMap<QString, QRect>::ConstIterator it = adjustedFaces.constBegin();
+
+    for ( ; it != adjustedFaces.constEnd() ; ++it)
+    {
+        TagRegion region(it.value());
+
+        if (it.key().isEmpty())
+        {
+            int tagId = FaceTags::unknownPersonTagId();
+            FaceTagsIface face(FaceTagsIface::UnknownName, info.id(), tagId, region);
+
+            addManually(face);
+        }
+        else
+        {
+            int tagId = FaceTags::getOrCreateTagForPerson(it.key());
+
+            if (!tagId)
+            {
+                qCDebug(DIGIKAM_GENERAL_LOG) << "Failed to create a person tag for name" << it.key();
+            }
+
+            add(info.id(), tagId, region, false);
+        }
+    }
+
+    return newSize;
+}
+
 int FaceUtils::faceRectDisplayMargin(const QRect& rect)
 {
     /*
      * Do not change that value unless you know what you do.
      * There are a lot of pregenerated thumbnails in user's databases,
      * expensive to regenerate, depending on this very value.
      */
     int margin = qMax(rect.width(), rect.height());
     margin    /= 10;
 
     return margin;
 }
 
 } // Namespace Digikam
diff --git a/core/utilities/facemanagement/database/faceutils.h b/core/utilities/facemanagement/database/faceutils.h
index 7de25f1045..2666f560c1 100644
--- a/core/utilities/facemanagement/database/faceutils.h
+++ b/core/utilities/facemanagement/database/faceutils.h
@@ -1,142 +1,148 @@
 /* ============================================================
  *
  * This file is a part of digiKam project
  * https://www.digikam.org
  *
  * Date        : 2010-08-08
  * Description : FacesEngine database interface allowing easy manipulation of face tags
  *
  * Copyright (C) 2010-2011 by Aditya Bhatt <adityabhatt1991 at gmail dot com>
  * Copyright (C) 2010-2011 by Marcel Wiesweg <marcel dot wiesweg at gmx dot de>
  * Copyright (C) 2012-2020 by Gilles Caulier <caulier dot gilles at gmail dot 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, 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.
  *
  * ============================================================ */
 
 #ifndef DIGIKAM_FACE_UTILS_H
 #define DIGIKAM_FACE_UTILS_H
 
 // Qt includes
 
 #include <QStringList>
 
 // Local includes
 
 #include "identity.h"
 #include "recognitiondatabase.h"
 #include "iteminfo.h"
 #include "facetagseditor.h"
 #include "digikam_export.h"
 
 class QImage;
 
 namespace Digikam
 {
 
 class DImg;
 class ThumbnailLoadThread;
 class ThumbnailImageCatcher;
 
 class FaceUtils : public FaceTagsEditor
 {
 public:
 
     enum FaceRecognitionSteps
     {
         DetectFaceRegions,
         DetectAndRecognize
     };
 
 public:
 
     explicit FaceUtils();
     virtual ~FaceUtils();
 
     // --- Face detection and recognition ---
 
     /**
      * The given face list is a result of automatic detection and possibly recognition.
      * The results are written to the database and merged with existing entries.
      * The returned list contains the faces written to the database and has the same size as the given list.
      * If a face was skipped (because of an existing entry), a null FaceTagsIface will be at this place.
      */
     QList<FaceTagsIface> writeUnconfirmedResults(qlonglong imageid,
                                                  const QList<QRectF>& detectedFaces,
                                                  const QList<Identity> recognitionResults,
                                                  const QSize& fullSize);
 
     // --- Status flags ---
 
     /**
      * Tells if the image has been scanned for faces or not
      */
     bool                hasBeenScanned(const ItemInfo& info)                            const;
     bool                hasBeenScanned(qlonglong imageid)                               const;
 
     /**
      * Marks the image as scanned for faces.
      */
     void                markAsScanned(qlonglong imageid, bool hasBeenScanned = true)    const;
     void                markAsScanned(const ItemInfo& info, bool hasBeenScanned = true) const;
 
     // --- Utilities ---
 
     /**
      * This uses a thumbnail load thread to load the image detail.
      * If requested, the faces will be scaled to the given (fixed) size.
      */
 /*
     void                fillImageInFaces(ThumbnailImageCatcher* const catcher,
                                          const QString& filePath,
                                          QList<Face>& faceList,
                                          const QSize& scaleSize = QSize())              const;
 */
 
     /**
      * Store the needed thumbnails for the given faces. This can be a huge optimization
      * when the has already been loaded anyway.
      */
     void                storeThumbnails(ThumbnailLoadThread* const thread,
                                         const QString& filePath,
                                         const QList<FaceTagsIface>& databaseFaces,
                                         const DImg& image);
 
     /**
      * Conversion
      */
     QList<FaceTagsIface> toFaceTagsIfaces(qlonglong imageid,
                                          const QList<QRectF>& detectedFaces,
                                          const QList<Identity> recognitionResults,
                                          const QSize& fullSize)                         const;
 
+    /**
+     * Rotate face tags
+     */
+    QSize                rotateFaces(const ItemInfo& info, int newOrientation,
+                                                           int oldOrientation);
+
     /**
      * For display, it may be desirable to display a slightly larger region than the strict
      * face rectangle. This returns a pixel margin commonly used to increase the rectangle size
      * in all four directions.
      */
     static int          faceRectDisplayMargin(const QRect& rect);
 
     Identity identityForTag(int tagId, RecognitionDatabase& db)                         const;
     int                  tagForIdentity(const Identity& identity)                       const;
 
 protected:
 
     // Reimplemented
     virtual void addNormalTag(qlonglong imageid, int tagId);
     virtual void removeNormalTag(qlonglong imageid, int tagId);
     virtual void removeNormalTags(qlonglong imageid, QList<int> tagId);
 };
 
 } // Namespace Digikam
 
 #endif // DIGIKAM_FACE_UTILS_H