diff --git a/core/app/views/tableview/tableview_column_digikam.cpp b/core/app/views/tableview/tableview_column_digikam.cpp
index 2b21ea6b08..557099bd09 100644
--- a/core/app/views/tableview/tableview_column_digikam.cpp
+++ b/core/app/views/tableview/tableview_column_digikam.cpp
@@ -1,476 +1,563 @@
 /* ============================================================
  *
  * This file is a part of digiKam project
  * https://www.digikam.org
  *
  * Date        : 2013-02-28
  * Description : Table view column helpers: Digikam properties
  *
  * Copyright (C) 2017-2020 by Gilles Caulier <caulier dot gilles at gmail dot com>
  * Copyright (C) 2013      by Michael G. Hansen <mike at mghansen 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 "tableview_column_digikam.h"
 
 // Qt includes
 
 #include <QLocale>
 
 // KDE includes
 
 #include <klocalizedstring.h>
 
 // Local includes
 
 #include "digikam_debug.h"
 #include "coredbfields.h"
 #include "albummanager.h"
 #include "digikam_globals.h"
 #include "iteminfo.h"
 
 namespace Digikam
 {
 
 namespace TableViewColumns
 {
 
 ColumnDigikamProperties::ColumnDigikamProperties(TableViewShared* const tableViewShared,
                                                  const TableViewColumnConfiguration& pConfiguration,
                                                  const SubColumn pSubColumn,
                                                  QObject* const parent)
     : TableViewColumn(tableViewShared, pConfiguration, parent),
       subColumn(pSubColumn)
 {
 }
 
 ColumnDigikamProperties::~ColumnDigikamProperties()
 {
 }
 
 QStringList ColumnDigikamProperties::getSubColumns()
 {
     QStringList columns;
     columns << QLatin1String("digikam-rating")
             << QLatin1String("digikam-picklabel")
             << QLatin1String("digikam-colorlabel")
             << QLatin1String("digikam-title")
             << QLatin1String("digikam-caption")
             << QLatin1String("digikam-tags");
 
     return columns;
 }
 
 TableViewColumnDescription ColumnDigikamProperties::getDescription()
 {
     TableViewColumnDescription description(QLatin1String("digikam-properties"), i18n("digiKam properties"));
     description.setIcon(QLatin1String("edit-text-frame-update"));
 
     description.addSubColumn(TableViewColumnDescription(QLatin1String("digikam-rating"),     i18n("Rating")).setIcon(QLatin1String("draw-star")));
     description.addSubColumn(TableViewColumnDescription(QLatin1String("digikam-picklabel"),  i18n("Pick label")).setIcon(QLatin1String("flag")));
     description.addSubColumn(TableViewColumnDescription(QLatin1String("digikam-colorlabel"), i18n("Color label")));
 
     /// @todo This column will show the 'default' title. Add a configuration dialog to choose different languages.
 
     description.addSubColumn(TableViewColumnDescription(QLatin1String("digikam-title"),      i18n("Title")));
 
     /// @todo This column will show the 'default' caption. Add a configuration dialog to choose different languages.
 
     description.addSubColumn(TableViewColumnDescription(QLatin1String("digikam-caption"),    i18n("Caption")));
 
     description.addSubColumn(TableViewColumnDescription(QLatin1String("digikam-tags"),       i18n("Tags")).setIcon(QLatin1String("tags")));
 
     return description;
 }
 
 QString ColumnDigikamProperties::getTitle() const
 {
     switch (subColumn)
     {
         case SubColumnRating:
+        {
             return i18n("Rating");
+        }
 
         case SubColumnPickLabel:
+        {
             return i18n("Pick label");
+        }
 
         case SubColumnColorLabel:
+        {
             return i18n("Color label");
+        }
 
         case SubColumnTitle:
+        {
             return i18n("Title");
+        }
 
         case SubColumnCaption:
+        {
             return i18n("Caption");
+        }
 
         case SubColumnTags:
+        {
             return i18n("Tags");
+        }
     }
 
     return QString();
 }
 
 TableViewColumn::ColumnFlags ColumnDigikamProperties::getColumnFlags() const
 {
     ColumnFlags flags(ColumnNoFlags);
 
     if (
         (subColumn == SubColumnRating)    ||
         (subColumn == SubColumnPickLabel) ||
         (subColumn == SubColumnColorLabel)
        )
     {
         flags |= ColumnCustomSorting;
     }
 
     return flags;
 }
 
 QVariant ColumnDigikamProperties::data(TableViewModel::Item* const item, const int role) const
 {
     if (
         (role != Qt::DisplayRole)       &&
         (role != Qt::TextAlignmentRole) &&
         (role != Qt::ForegroundRole)
        )
     {
         return QVariant();
     }
 
     if (role == Qt::TextAlignmentRole)
     {
         switch (subColumn)
         {
             case SubColumnRating:
+            {
                 return QVariant(Qt::Alignment(Qt::AlignCenter));
+            }
 
             default:
+            {
                 return QVariant();
+            }
         }
     }
 
     if (role == Qt::ForegroundRole)
     {
         switch (subColumn)
         {
             case SubColumnPickLabel:
             {
-                const ItemInfo info      = s->tableViewModel->infoFromItem(item);
+                const ItemInfo info       = s->tableViewModel->infoFromItem(item);
                 const PickLabel pickLabel = PickLabel(info.pickLabel());
                 QColor labelColor;
 
                 switch (pickLabel)
                 {
                     case NoPickLabel:
+                    {
                         labelColor = Qt::darkGray;
                         break;
+                    }
 
                     case RejectedLabel:
+                    {
                         labelColor = Qt::red;
                         break;
+                    }
 
                     case PendingLabel:
-
+                    {
                         // yellow is too hard to read
 
                         labelColor = Qt::darkYellow;
                         break;
+                    }
 
                     case AcceptedLabel:
-
+                    {
                         // green is too hard to read
 
                         labelColor = Qt::darkGreen;
                         break;
+                    }
 
                     default:
+                    {
                         break;
+                    }
                 }
 
                 QBrush labelBrush(labelColor);
 
                 return QVariant::fromValue(labelBrush);
             }
 
             case SubColumnColorLabel:
             {
                 const ItemInfo info        = s->tableViewModel->infoFromItem(item);
                 const ColorLabel colorLabel = ColorLabel(info.colorLabel());
                 QColor labelColor;
 
                 switch (colorLabel)
                 {
                     case NoColorLabel:
+                    {
                         labelColor = Qt::lightGray;
                         break;
+                    }
 
                     case RedLabel:
+                    {
                         labelColor = Qt::red;
                         break;
+                    }
 
                     case OrangeLabel:
+                    {
                         labelColor = QColor(0xff, 0x80, 0x00);
                         break;
+                    }
 
                     case YellowLabel:
+                    {
                         labelColor = Qt::darkYellow;
                         break;
+                    }
 
                     case GreenLabel:
+                    {
                         labelColor = Qt::darkGreen;
                         break;
+                    }
 
                     case BlueLabel:
+                    {
                         labelColor = Qt::darkBlue;
                         break;
+                    }
 
                     case MagentaLabel:
+                    {
                         labelColor = Qt::magenta;
                         break;
+                    }
 
                     case GrayLabel:
+                    {
                         labelColor = Qt::darkGray;
                         break;
+                    }
 
                     case BlackLabel:
+                    {
                         labelColor = Qt::black;
                         break;
+                    }
 
                     case WhiteLabel:
+                    {
                         labelColor = Qt::white;
                         break;
+                    }
 
                     default:
+                    {
                         break;
+                    }
                 }
 
                 QBrush labelBrush(labelColor);
 
                 return QVariant::fromValue(labelBrush);
             }
 
             default:
             {
                 return QVariant();
             }
         }
     }
 
     const ItemInfo info = s->tableViewModel->infoFromItem(item);
 
     /**
      * @todo Also display the pick label icon?
      *       Make display of text/icon configurable.
      */
 
     switch (subColumn)
     {
         case SubColumnRating:
         {
             const int itemRating = info.rating();
 
             if (itemRating <= 0)
             {
                 // no rating
 
                 return QString();
             }
 
             return QLocale().toString(itemRating);
         }
 
         case SubColumnPickLabel:
         {
             const PickLabel pickLabel = PickLabel(info.pickLabel());
             QString labelString;
 
             switch (pickLabel)
             {
                 case NoPickLabel:
+                {
                     labelString = i18n("None");
                     break;
+                }
 
                 case RejectedLabel:
+                {
                     labelString = i18n("Rejected");
                     break;
+                }
 
                 case PendingLabel:
+                {
                     labelString = i18n("Pending");
                     break;
+                }
 
                 case AcceptedLabel:
+                {
                     labelString = i18n("Accepted");
                     break;
+                }
 
                 default:
+                {
                     break;
+                }
             }
 
             return labelString;
         }
 
         case SubColumnColorLabel:
         {
             const ColorLabel colorLabel = ColorLabel(info.colorLabel());
             QString labelString;
 
             switch (colorLabel)
             {
                 case NoColorLabel:
+                {
                     labelString = i18n("None");
                     break;
+                }
 
                 case RedLabel:
+                {
                     labelString = i18n("Red");
                     break;
+                }
 
                 case OrangeLabel:
+                {
                     labelString = i18n("Orange");
                     break;
+                }
 
                 case YellowLabel:
+                {
                     labelString = i18n("Yellow");
                     break;
+                }
 
                 case GreenLabel:
+                {
                     labelString = i18n("Green");
                     break;
+                }
 
                 case BlueLabel:
+                {
                     labelString = i18n("Blue");
                     break;
+                }
 
                 case MagentaLabel:
+                {
                     labelString = i18n("Magenta");
                     break;
+                }
 
                 case GrayLabel:
+                {
                     labelString = i18n("Gray");
                     break;
+                }
 
                 case BlackLabel:
+                {
                     labelString = i18n("Black");
                     break;
+                }
 
                 case WhiteLabel:
+                {
                     labelString = i18n("White");
                     break;
+                }
 
                 default:
+                {
                     break;
+                }
             }
 
             return labelString;
         }
 
         case SubColumnTitle:
         {
             const QString title = info.title();
 
             return title;
         }
 
         case SubColumnCaption:
         {
             const QString caption = info.comment();
 
             return caption;
         }
 
         case SubColumnTags:
         {
             QStringList tagPaths = AlbumManager::instance()->tagPaths(info.tagIds(), false);
             tagPaths.sort();
 
-            return tagPaths;
+            return tagPaths.join(QLatin1Char('\n'));
         }
 
     }
 
     return QVariant();
 }
 
 TableViewColumn::ColumnCompareResult ColumnDigikamProperties::compare(TableViewModel::Item* const itemA,
                                                                       TableViewModel::Item* const itemB) const
 {
     const ItemInfo infoA = s->tableViewModel->infoFromItem(itemA);
     const ItemInfo infoB = s->tableViewModel->infoFromItem(itemB);
 
     switch (subColumn)
     {
         case SubColumnRating:
         {
             /// @todo Handle un-rated vs rated items differently?
 
             const int ratingA = infoA.rating();
             const int ratingB = infoB.rating();
 
             return compareHelper<int>(ratingA, ratingB);
         }
 
         case SubColumnPickLabel:
         {
             /// @todo Handle un-rated vs rated items differently?
 
             const int pickLabelA = infoA.pickLabel();
             const int pickLabelB = infoB.pickLabel();
 
             return compareHelper<int>(pickLabelA, pickLabelB);
         }
 
         case SubColumnColorLabel:
         {
             /// @todo Handle un-rated vs rated items differently?
 
             const int colorLabelA = infoA.colorLabel();
             const int colorLabelB = infoB.colorLabel();
 
             return compareHelper<int>(colorLabelA, colorLabelB);
         }
 
         default:
         {
             qCWarning(DIGIKAM_GENERAL_LOG) << "item: unimplemented comparison, subColumn=" << subColumn;
+
             return CmpEqual;
         }
     }
 }
 
 bool Digikam::TableViewColumns::ColumnDigikamProperties::columnAffectedByChangeset(const Digikam::ImageChangeset& imageChangeset) const
 {
     switch (subColumn)
     {
         case SubColumnTitle:
         case SubColumnCaption:
         case SubColumnTags:
+        {
             return true;
-
             /// @todo These are not the right flags for these columns
 /*
             return imageChangeset.changes() & DatabaseFields::ItemCommentsAll;
 */
+        }
+
         case SubColumnRating:
+        {
             return (imageChangeset.changes() & DatabaseFields::Rating);
+        }
 
         case SubColumnPickLabel:
+        {
             return (imageChangeset.changes() & DatabaseFields::PickLabel);
+        }
 
         case SubColumnColorLabel:
+        {
             return (imageChangeset.changes() & DatabaseFields::ColorLabel);
+        }
     }
 
     return false;
 }
 
 } // namespace TableViewColumns
 
 } // namespace Digikam
diff --git a/core/app/views/tableview/tableview_columnfactory.cpp b/core/app/views/tableview/tableview_columnfactory.cpp
index 6f0ffacb26..2980cc4cb2 100644
--- a/core/app/views/tableview/tableview_columnfactory.cpp
+++ b/core/app/views/tableview/tableview_columnfactory.cpp
@@ -1,355 +1,357 @@
 /* ============================================================
  *
  * This file is a part of digiKam project
  * https://www.digikam.org
  *
  * Date        : 2013-02-12
  * Description : Table view column helpers
  *
  * Copyright (C) 2017-2020 by Gilles Caulier <caulier dot gilles at gmail dot com>
  * Copyright (C) 2013      by Michael G. Hansen <mike at mghansen 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 "tableview_columnfactory.h"
 
 // KDE include
 
 #include <kconfiggroup.h>
 
 // Local includes
 
 #include "digikam_debug.h"
 #include "itemfiltermodel.h"
 #include "iteminfo.h"
 #include "tableview_columns.h"
 
 namespace Digikam
 {
 
 TableViewColumn::TableViewColumn(TableViewShared* const tableViewShared,
                                  const TableViewColumnConfiguration& pConfiguration,
                                  QObject* const parent)
     : QObject(parent),
       s(tableViewShared),
       configuration(pConfiguration)
 {
 }
 
 TableViewColumn::~TableViewColumn()
 {
 }
 
 // ---------------------------------------------------------------------------------------------
 
 TableViewColumnFactory::TableViewColumnFactory(TableViewShared* const tableViewShared,
                                                QObject* const parent)
     : QObject(parent),
       s(tableViewShared)
 {
 }
 
 TableViewColumn* TableViewColumnFactory::getColumn(const Digikam::TableViewColumnConfiguration& columnConfiguration)
 {
     TableViewColumn* newColumn = nullptr;
 
     if (TableViewColumns::ColumnThumbnail::CreateFromConfiguration(s, columnConfiguration, &newColumn, this))
     {
         return newColumn;
     }
 
     if (TableViewColumns::ColumnDigikamProperties::CreateFromConfiguration<TableViewColumns::ColumnDigikamProperties>(s, columnConfiguration, &newColumn, this))
     {
         return newColumn;
     }
 
     if (TableViewColumns::ColumnPhotoProperties::CreateFromConfiguration<TableViewColumns::ColumnPhotoProperties>(s, columnConfiguration, &newColumn, this))
     {
         return newColumn;
     }
 
     if (TableViewColumns::ColumnFileProperties::CreateFromConfiguration<TableViewColumns::ColumnFileProperties>(s, columnConfiguration, &newColumn, this))
     {
         return newColumn;
     }
 
     if (TableViewColumns::ColumnGeoProperties::CreateFromConfiguration<TableViewColumns::ColumnGeoProperties>(s, columnConfiguration, &newColumn, this))
     {
         return newColumn;
     }
 
     if (TableViewColumns::ColumnItemProperties::CreateFromConfiguration<TableViewColumns::ColumnItemProperties>(s, columnConfiguration, &newColumn, this))
     {
         return newColumn;
     }
 
     if (TableViewColumns::ColumnAudioVideoProperties::CreateFromConfiguration<TableViewColumns::ColumnAudioVideoProperties>(s, columnConfiguration, &newColumn, this))
     {
         return newColumn;
     }
 
     return nullptr;
 }
 
 QList<TableViewColumnDescription> TableViewColumnFactory::getColumnDescriptionList()
 {
     QList<TableViewColumnDescription> descriptionList;
 
     descriptionList << TableViewColumns::ColumnThumbnail::getDescription();
     descriptionList << TableViewColumns::ColumnFileProperties::getDescription();
     descriptionList << TableViewColumns::ColumnItemProperties::getDescription();
     descriptionList << TableViewColumns::ColumnPhotoProperties::getDescription();
     descriptionList << TableViewColumns::ColumnDigikamProperties::getDescription();
     descriptionList << TableViewColumns::ColumnGeoProperties::getDescription();
     descriptionList << TableViewColumns::ColumnAudioVideoProperties::getDescription();
 
     return descriptionList;
 }
 
 // ---------------------------------------------------------------------------------------------
 
 bool TableViewColumn::paint(QPainter* const painter, const QStyleOptionViewItem& option, TableViewModel::Item* const item) const
 {
     Q_UNUSED(painter)
     Q_UNUSED(option)
     Q_UNUSED(item)
 
     return false;
 }
 
 QSize TableViewColumn::sizeHint(const QStyleOptionViewItem& option, TableViewModel::Item* const item) const
 {
     Q_UNUSED(option)
     Q_UNUSED(item)
 
     return QSize();
 }
 
 QVariant TableViewColumn::data(TableViewModel::Item* const item, const int role) const
 {
     Q_UNUSED(item)
     Q_UNUSED(role)
 
     return QVariant();
 }
 
 TableViewColumn::ColumnFlags TableViewColumn::getColumnFlags() const
 {
     return ColumnNoFlags;
 }
 
 TableViewColumnConfiguration TableViewColumn::getConfiguration() const
 {
     return configuration;
 }
 
 /**
  * This function should never be called, because subclasses have to do the comparison on their own. But it can not be
  * pure, since then every subclass which does not do custom comparison would have to implement an empty stub.
  */
 TableViewColumn::ColumnCompareResult TableViewColumn::compare(TableViewModel::Item* const itemA, TableViewModel::Item* const itemB) const
 {
     Q_UNUSED(itemA)
     Q_UNUSED(itemB)
 
     qCWarning(DIGIKAM_GENERAL_LOG) << "Unimplemented custom comparison. Make sure getColumnFlags() does not return ColumnCustomSorting.";
 
     return CmpEqual;
 }
 
 TableViewColumnConfigurationWidget* TableViewColumn::getConfigurationWidget(QWidget* const parentWidget) const
 {
     Q_UNUSED(parentWidget)
 
     return nullptr;
 }
 
 void TableViewColumn::setConfiguration(const TableViewColumnConfiguration& newConfiguration)
 {
     Q_UNUSED(newConfiguration)
 }
 
 void TableViewColumn::updateThumbnailSize()
 {
 }
 
 bool TableViewColumn::compareHelperBoolFailCheck(const bool okA, const bool okB, ColumnCompareResult* const result)
 {
     if (okA && okB)
     {
         return true;
     }
 
     if (okA && !okB)
     {
         *result = CmpABiggerB;
+
         return false;
     }
 
     if (okB && !okA)
     {
         *result = CmpALessB;
+
         return false;
     }
 
     *result = CmpEqual;
 
     return false;
 }
 
 bool TableViewColumn::columnAffectedByChangeset(const ImageChangeset& /*imageChangeset*/) const
 {
     return true;
 }
 
 // ---------------------------------------------------------------------------------------------
 
 TableViewColumnProfile::TableViewColumnProfile()
 {
 }
 
 TableViewColumnProfile::~TableViewColumnProfile()
 {
 }
 
 void TableViewColumnProfile::loadSettings(const KConfigGroup& configGroup)
 {
     name               = configGroup.readEntry("Profile Name", QString());
     headerState        = configGroup.readEntry("Header State", QByteArray());
     const int nColumns = configGroup.readEntry("Column Count", int(0));
 
     for (int i = 0 ; i < nColumns ; ++i)
     {
         /// @todo check for invalid column configurations
 
         const QString configSubGroupName = QString::fromUtf8("Column %1").arg(i);
         const KConfigGroup subGroup      = configGroup.group(configSubGroupName);
 
         /// @todo move loading into TableViewColumnConfiguration
 
         TableViewColumnConfiguration columnConfiguration;
         columnConfiguration.loadSettings(subGroup);
 
         columnConfigurationList << columnConfiguration;
     }
 
     if (columnConfigurationList.isEmpty())
     {
         // no data loaded, create default entries
 
         /// @todo Set the default sorting column to something other than the thumbnail.
 
         TableViewColumnDescription::List allColumns = TableViewColumnFactory::getColumnDescriptionList();
 
         TableViewColumnDescription nextDesc;
 
         if (TableViewColumnDescription::FindInListById(allColumns, QLatin1String("thumbnail"), &nextDesc))
         {
             columnConfigurationList << nextDesc.toConfiguration();
         }
 
         if (TableViewColumnDescription::FindInListById(allColumns, QLatin1String("filename"), &nextDesc))
         {
             columnConfigurationList << nextDesc.toConfiguration();
         }
 
         if (TableViewColumnDescription::FindInListById(allColumns, QLatin1String("digikam-rating"), &nextDesc))
         {
             columnConfigurationList << nextDesc.toConfiguration();
         }
 
         if (TableViewColumnDescription::FindInListById(allColumns, QLatin1String("itemcreationdatetime"), &nextDesc))
         {
             columnConfigurationList << nextDesc.toConfiguration();
         }
 
         if (TableViewColumnDescription::FindInListById(allColumns, QLatin1String("digikam-title"), &nextDesc))
         {
             columnConfigurationList << nextDesc.toConfiguration();
         }
 
         if (TableViewColumnDescription::FindInListById(allColumns, QLatin1String("digikam-tags"), &nextDesc))
         {
             columnConfigurationList << nextDesc.toConfiguration();
         }
     }
 }
 
 void TableViewColumnProfile::saveSettings(KConfigGroup& configGroup)
 {
     configGroup.writeEntry(QLatin1String("Profile Name"), name);
     const int nColumns = columnConfigurationList.count();
     configGroup.writeEntry(QLatin1String("Column Count"), nColumns);
     configGroup.writeEntry(QLatin1String("Header State"), headerState);
 
     for (int i = 0 ; i < nColumns ; ++i)
     {
         const QString configSubGroupName                        = QString::fromUtf8("Column %1").arg(i);
         KConfigGroup subGroup                                   = configGroup.group(configSubGroupName);
         const TableViewColumnConfiguration& columnConfiguration = columnConfigurationList.at(i);;
         columnConfiguration.saveSettings(subGroup);
     }
 }
 
 // ---------------------------------------------------------------------------------------------
 
 void TableViewColumnConfiguration::loadSettings(const KConfigGroup& configGroup)
 {
     columnId            = configGroup.readEntry(QLatin1String("Column Id"), QString());
     const int nSettings = configGroup.readEntry(QLatin1String("NSettings"), int(0));
 
     for (int i = 0 ; i < nSettings ; ++i)
     {
         const QString& key   = configGroup.readEntry(QString::fromUtf8("Key %1").arg(i),   QString());
         const QString& value = configGroup.readEntry(QString::fromUtf8("Value %1").arg(i), QString());
 
         if (!key.isEmpty())
         {
             columnSettings.insert(key, value);
         }
     }
 }
 
 void TableViewColumnConfiguration::saveSettings(KConfigGroup& configGroup) const
 {
     configGroup.writeEntry(QLatin1String("Column Id"), columnId);
 
     const int nSettings = columnSettings.count();
     configGroup.writeEntry(QLatin1String("NSettings"), nSettings);
 
     QHashIterator<QString, QString> settingsIterator(columnSettings);
 
     for (int i = 0 ; settingsIterator.hasNext() ; ++i)
     {
         settingsIterator.next();
         configGroup.writeEntry(QString::fromUtf8("Key %1").arg(i),   settingsIterator.key());
         configGroup.writeEntry(QString::fromUtf8("Value %1").arg(i), settingsIterator.value());
     }
 }
 
 // ---------------------------------------------------------------------------------------------
 
 TableViewColumnConfigurationWidget::TableViewColumnConfigurationWidget(TableViewShared* const sharedObject,
                                                                        const TableViewColumnConfiguration& currentConfiguration,
                                                                        QWidget* const parent)
     : QWidget(parent),
       s(sharedObject),
       configuration(currentConfiguration)
 {
 }
 
 TableViewColumnConfigurationWidget::~TableViewColumnConfigurationWidget()
 {
 }
 
 } // namespace Digikam
diff --git a/core/app/views/tableview/tableview_columnfactory.h b/core/app/views/tableview/tableview_columnfactory.h
index bc41e9a967..9ecc347af1 100644
--- a/core/app/views/tableview/tableview_columnfactory.h
+++ b/core/app/views/tableview/tableview_columnfactory.h
@@ -1,339 +1,346 @@
 /* ============================================================
  *
  * This file is a part of digiKam project
  * https://www.digikam.org
  *
  * Date        : 2013-02-12
  * Description : Table view column helpers
  *
  * Copyright (C) 2017-2020 by Gilles Caulier <caulier dot gilles at gmail dot com>
  * Copyright (C) 2013      by Michael G. Hansen <mike at mghansen 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.
  *
  * ============================================================ */
 
 #ifndef DIGIKAM_TABLE_VIEW_COLUMNFACTORY_H
 #define DIGIKAM_TABLE_VIEW_COLUMNFACTORY_H
 
 // Qt includes
 
 #include <QObject>
 #include <QHash>
 #include <QWidget>
 
 // Local includes
 
 #include "tableview_model.h"
 #include "tableview_shared.h"
 
 class QModelIndex;
 class QStyleOptionViewItem;
 
 class KConfigGroup;
 
 namespace Digikam
 {
 
 class ItemInfo;
 class ThumbnailSize;
 
 class TableViewColumnConfiguration
 {
 public:
 
     explicit TableViewColumnConfiguration(const QString& id = QString())
       : columnId(id),
         columnSettings()
     {
     }
 
     QString getSetting(const QString& key, const QString& defaultValue = QString()) const
     {
         if (!columnSettings.contains(key))
         {
             return defaultValue;
         }
 
         return columnSettings.value(key);
     }
 
     void loadSettings(const KConfigGroup& configGroup);
     void saveSettings(KConfigGroup& configGroup) const;
 
 public:
 
     QString                 columnId;
     QHash<QString, QString> columnSettings;
 };
 
 // ----------------------------------------------------------------------------
 
 class TableViewColumnDescription
 {
 public:
 
     explicit TableViewColumnDescription()
       : columnId(),
         columnTitle(),
         columnIcon(),
         columnSettings(),
         subColumns()
     {
     }
 
     explicit TableViewColumnDescription(const QString& id, const QString& title,
                                         const QString& settingKey = QString(),
                                         const QString& settingValue = QString())
       : columnId(id),
         columnTitle(title),
         columnIcon(),
         columnSettings(),
         subColumns()
     {
         if (!settingKey.isEmpty())
         {
             addSetting(settingKey, settingValue);
         }
     }
 
 public:
 
     typedef QList<TableViewColumnDescription> List;
 
-    QString                           columnId;
-    QString                           columnTitle;
-    QString                           columnIcon;
-    QHash<QString, QString>           columnSettings;
-    QList<TableViewColumnDescription> subColumns;
+    QString                                   columnId;
+    QString                                   columnTitle;
+    QString                                   columnIcon;
+    QHash<QString, QString>                   columnSettings;
+    QList<TableViewColumnDescription>         subColumns;
 
 public:
 
     void addSubColumn(const TableViewColumnDescription& subColumnDescription)
     {
         subColumns << subColumnDescription;
     }
 
     void addSetting(const QString& key, const QString& value)
     {
         columnSettings.insert(key, value);
     }
 
     TableViewColumnConfiguration toConfiguration() const
     {
         TableViewColumnConfiguration configuration;
 
         configuration.columnId       = columnId;
         configuration.columnSettings = columnSettings;
 
         return configuration;
     }
 
     TableViewColumnDescription setIcon(const QString& iconName)
     {
         columnIcon = iconName;
 
         return *this;
     }
 
     static bool FindInListById(const TableViewColumnDescription::List& listToSearch, const QString& targetId, TableViewColumnDescription* const resultDescription)
     {
         TableViewColumnDescription::List leftToSearch = listToSearch;
 
         while (!leftToSearch.isEmpty())
         {
             const TableViewColumnDescription desc = leftToSearch.takeFirst();
 
             if (desc.columnId == targetId)
             {
                 *resultDescription = desc;
 
                 return true;
             }
 
             if (!desc.subColumns.isEmpty())
             {
                 leftToSearch << desc.subColumns;
             }
         }
 
         return false;
     }
 };
 
 // ----------------------------------------------------------------------------
 
 class TableViewColumnConfigurationWidget : public QWidget
 {
     Q_OBJECT
 
 public:
 
     explicit TableViewColumnConfigurationWidget(TableViewShared* const sharedObject,
                                                 const TableViewColumnConfiguration& currentConfiguration,
                                                 QWidget* const parent = nullptr);
     virtual ~TableViewColumnConfigurationWidget();
 
     virtual TableViewColumnConfiguration getNewConfiguration() = 0;
 
 public:
 
     TableViewShared* const       s;
     TableViewColumnConfiguration configuration;
 };
 
 // ----------------------------------------------------------------------------
 
 class TableViewColumn : public QObject
 {
     Q_OBJECT
 
 protected:
 
     TableViewShared* const       s;
     TableViewColumnConfiguration configuration;
 
 public:
 
     enum ColumnFlag
     {
         ColumnNoFlags                = 0,
         ColumnCustomPainting         = 1,
         ColumnCustomSorting          = 2,
         ColumnHasConfigurationWidget = 4
     };
     Q_DECLARE_FLAGS(ColumnFlags, ColumnFlag)
 
     enum ColumnCompareResult
     {
-        CmpEqual    = 0,
-        CmpABiggerB = 1,
-        CmpALessB   = 2
+        CmpEqual                     = 0,
+        CmpABiggerB                  = 1,
+        CmpALessB                    = 2
     };
 
 public:
 
     explicit TableViewColumn(TableViewShared* const tableViewShared,
                              const TableViewColumnConfiguration& pConfiguration,
                              QObject* const parent = nullptr);
     virtual ~TableViewColumn();
 
+public:
+
     virtual TableViewColumnConfiguration getConfiguration()                                                             const;
     virtual void setConfiguration(const TableViewColumnConfiguration& newConfiguration);
     virtual TableViewColumnConfigurationWidget* getConfigurationWidget(QWidget* const parentWidget)                     const;
     virtual ColumnFlags getColumnFlags()                                                                                const;
     virtual QString getTitle()                                                                                          const = 0;
 
     virtual QVariant data(TableViewModel::Item* const item, const int role)                                             const;
     virtual ColumnCompareResult compare(TableViewModel::Item* const itemA, TableViewModel::Item* const itemB)           const;
     virtual bool columnAffectedByChangeset(const ImageChangeset& imageChangeset)                                        const;
     virtual bool paint(QPainter* const painter, const QStyleOptionViewItem& option, TableViewModel::Item* const item)   const;
     virtual QSize sizeHint(const QStyleOptionViewItem& option, TableViewModel::Item* const item)                        const;
     virtual void updateThumbnailSize();
 
+public:
+
     static TableViewColumnDescription getDescription();
     static bool compareHelperBoolFailCheck(const bool okA, const bool okB, ColumnCompareResult* const result);
 
-    template<class MyType> static ColumnCompareResult compareHelper(const MyType& A, const MyType& B)
+    template<class MyType>
+    static ColumnCompareResult compareHelper(const MyType& A, const MyType& B)
     {
         if      (A == B)
         {
             return CmpEqual;
         }
         else if (A > B)
         {
             return CmpABiggerB;
         }
 
         return CmpALessB;
     }
 
-    template<typename columnClass> static bool getSubColumnIndex(const QString& subColumnId, typename columnClass::SubColumn* const subColumn)
+    template<typename columnClass>
+    static bool getSubColumnIndex(const QString& subColumnId, typename columnClass::SubColumn* const subColumn)
     {
         const int index = columnClass::getSubColumns().indexOf(subColumnId);
 
         if (index < 0)
         {
             return false;
         }
 
         *subColumn = typename columnClass::SubColumn(index);
 
         return true;
     }
 
-    template<typename columnClass> static bool CreateFromConfiguration(TableViewShared* const tableViewShared,
-                                                                       const TableViewColumnConfiguration& pConfiguration,
-                                                                       TableViewColumn** const pNewColumn,
-                                                                       QObject* const parent)
+    template<typename columnClass>
+    static bool CreateFromConfiguration(TableViewShared* const tableViewShared,
+                                        const TableViewColumnConfiguration& pConfiguration,
+                                        TableViewColumn** const pNewColumn,
+                                        QObject* const parent)
     {
         typename columnClass::SubColumn subColumn;
 
         if (!getSubColumnIndex<columnClass>(pConfiguration.columnId, &subColumn))
         {
             return false;
         }
 
         *pNewColumn = new columnClass(tableViewShared, pConfiguration, subColumn, parent);
 
         return true;
     }
 
 Q_SIGNALS:
 
     void signalDataChanged(const qlonglong imageId);
     void signalAllDataChanged();
 };
 
 // ----------------------------------------------------------------------------
 
 class TableViewColumnFactory : public QObject
 {
     Q_OBJECT
 
 public:
 
     explicit TableViewColumnFactory(TableViewShared* const tableViewShared, QObject* const parent = nullptr);
 
     static QList<TableViewColumnDescription> getColumnDescriptionList();
     TableViewColumn* getColumn(const TableViewColumnConfiguration& columnConfiguration);
 
 private:
 
     TableViewShared* const s;
 };
 
 // ----------------------------------------------------------------------------
 
 class TableViewColumnProfile
 {
 public:
 
     TableViewColumnProfile();
     ~TableViewColumnProfile();
 
     void loadSettings(const KConfigGroup& configGroup);
     void saveSettings(KConfigGroup& configGroup);
 
 public:
 
     QList<TableViewColumnConfiguration> columnConfigurationList;
     QString                             name;
     QByteArray                          headerState;
 };
 
 } // namespace Digikam
 
 Q_DECLARE_METATYPE(Digikam::TableViewColumnDescription)
 
 Q_DECLARE_OPERATORS_FOR_FLAGS(Digikam::TableViewColumn::ColumnFlags)
 
 #endif // DIGIKAM_TABLE_VIEW_COLUMNFACTORY_H