Fix a bunch of Qt6/Kf6 warnings

[dolphin.git] / src / kitemviews / private / kbaloorolesprovider.cpp

diff --git a/src/kitemviews/private/kbaloorolesprovider.cpp b/src/kitemviews/private/kbaloorolesprovider.cpp
index df60a2533a173146db6438e6dff60ab6e51107e8..1a9bebb8ba679e8b5a9ef9a16dd38ffd38508d21 100644 (file)
--- a/src/kitemviews/private/kbaloorolesprovider.cpp
+++ b/src/kitemviews/private/kbaloorolesprovider.cpp
@@ -12,32 +12,61 @@
 #include <KFileMetaData/UserMetaData>
 
 #include <QCollator>
 #include <KFileMetaData/UserMetaData>
 
 #include <QCollator>

-#include <QDebug>
-#include <QTime>
-
-namespace {
-    QString tagsFromValues(const QStringList& values)
-    {
-        if (values.size() == 1) {
-            return values.at(0);
-        }
+#include <QSize>

 
 

-        QStringList alphabeticalOrderTags = values;
-        QCollator coll;
-        coll.setNumericMode(true);
-        std::sort(alphabeticalOrderTags.begin(), alphabeticalOrderTags.end(), [&](const QString& s1, const QString& s2){ return coll.compare(s1, s2) < 0; });
-        return alphabeticalOrderTags.join(QLatin1String(", "));
+namespace
+{
+QString tagsFromValues(const QStringList &values)
+{
+    if (values.size() == 1) {
+        return values.at(0);

     }
     }

+
+    QStringList alphabeticalOrderTags = values;
+    QCollator coll;
+    coll.setNumericMode(true);
+    std::sort(alphabeticalOrderTags.begin(), alphabeticalOrderTags.end(), [&](const QString &s1, const QString &s2) {
+        return coll.compare(s1, s2) < 0;
+    });
+    return alphabeticalOrderTags.join(QLatin1String(", "));

 }
 
 }
 

-struct KBalooRolesProviderSingleton
-{
+    using Property = KFileMetaData::Property::Property;
+    // Mapping from the KFM::Property to the KFileItemModel roles.
+    const QHash<Property, QByteArray> propertyRoleMap() {
+        static const auto map = QHash<Property, QByteArray> {
+            { Property::Rating,            QByteArrayLiteral("rating") },
+            { Property::Comment,           QByteArrayLiteral("comment") },
+            { Property::Title,             QByteArrayLiteral("title") },
+            { Property::Author,            QByteArrayLiteral("author") },
+            { Property::Publisher,         QByteArrayLiteral("publisher") },
+            { Property::PageCount,         QByteArrayLiteral("pageCount") },
+            { Property::WordCount,         QByteArrayLiteral("wordCount") },
+            { Property::LineCount,         QByteArrayLiteral("lineCount") },
+            { Property::Width,             QByteArrayLiteral("width") },
+            { Property::Height,            QByteArrayLiteral("height") },
+            { Property::ImageDateTime,     QByteArrayLiteral("imageDateTime") },
+            { Property::ImageOrientation,  QByteArrayLiteral("orientation") },
+            { Property::Artist,            QByteArrayLiteral("artist") },
+            { Property::Genre,             QByteArrayLiteral("genre")  },
+            { Property::Album,             QByteArrayLiteral("album") },
+            { Property::Duration,          QByteArrayLiteral("duration") },
+            { Property::BitRate,           QByteArrayLiteral("bitrate") },
+            { Property::AspectRatio,       QByteArrayLiteral("aspectRatio") },
+            { Property::FrameRate,         QByteArrayLiteral("frameRate") },
+            { Property::ReleaseYear,       QByteArrayLiteral("releaseYear") },
+            { Property::TrackNumber,       QByteArrayLiteral("track") }
+        };
+        return map;
+    }
+}
+
+struct KBalooRolesProviderSingleton {

     KBalooRolesProvider instance;
 };
 Q_GLOBAL_STATIC(KBalooRolesProviderSingleton, s_balooRolesProvider)
 
     KBalooRolesProvider instance;
 };
 Q_GLOBAL_STATIC(KBalooRolesProviderSingleton, s_balooRolesProvider)
 

-
-KBalooRolesProvider& KBalooRolesProvider::instance()
+KBalooRolesProvider &KBalooRolesProvider::instance()

 {
     return s_balooRolesProvider->instance;
 }
 {
     return s_balooRolesProvider->instance;
 }


@@ -51,37 +80,39 @@ QSet<QByteArray> KBalooRolesProvider::roles() const
     return m_roles;
 }
 
     return m_roles;
 }
 

-QHash<QByteArray, QVariant> KBalooRolesProvider::roleValues(const Baloo::File& file,
-                                                            const QSet<QByteArray>& roles) const
+QHash<QByteArray, QVariant> KBalooRolesProvider::roleValues(const Baloo::File &file, const QSet<QByteArray> &roles) const

 {
     QHash<QByteArray, QVariant> values;
 
 {
     QHash<QByteArray, QVariant> values;
 

-    using entry = std::pair<const KFileMetaData::Property::Property&, const QVariant&>;
+    using entry = std::pair<const KFileMetaData::Property::Property &, const QVariant &>;

 
 

-    const auto& propMap = file.properties();
+    const auto &propMap = file.properties();

     auto rangeBegin = propMap.constKeyValueBegin();
 
     while (rangeBegin != propMap.constKeyValueEnd()) {
         auto key = (*rangeBegin).first;
     auto rangeBegin = propMap.constKeyValueBegin();
 
     while (rangeBegin != propMap.constKeyValueEnd()) {
         auto key = (*rangeBegin).first;

-        const KFileMetaData::PropertyInfo propertyInfo(key);
-        const QByteArray role = roleForProperty(propertyInfo.name());

 
 

-        auto rangeEnd = std::find_if(rangeBegin, propMap.constKeyValueEnd(),
-            [key](const entry& e) { return e.first != key; });
+        auto rangeEnd = std::find_if(rangeBegin, propMap.constKeyValueEnd(), [key](const entry &e) {
+            return e.first != key;
+        });

 
 

+        const QByteArray role = propertyRoleMap().value(key);

         if (role.isEmpty() || !roles.contains(role)) {
             rangeBegin = rangeEnd;
             continue;
         }
 
         if (role.isEmpty() || !roles.contains(role)) {
             rangeBegin = rangeEnd;
             continue;
         }
 

+        const KFileMetaData::PropertyInfo propertyInfo(key);

         auto distance = std::distance(rangeBegin, rangeEnd);
         if (distance > 1) {
             QVariantList list;
             list.reserve(static_cast<int>(distance));
         auto distance = std::distance(rangeBegin, rangeEnd);
         if (distance > 1) {
             QVariantList list;
             list.reserve(static_cast<int>(distance));

-            std::for_each(rangeBegin, rangeEnd, [&list](const entry& s) { list.append(s.second); });
+            std::for_each(rangeBegin, rangeEnd, [&list](const entry &s) {
+                list.append(s.second);
+            });

             values.insert(role, propertyInfo.formatAsDisplayString(list));
         } else {
             values.insert(role, propertyInfo.formatAsDisplayString(list));
         } else {

-            if (propertyInfo.valueType() == QVariant::DateTime) {
+            if (propertyInfo.valueTypeId() == QMetaType::Type::DateTime) {

                 // Let dolphin format later Dates
                 values.insert(role, (*rangeBegin).second);
             } else {
                 // Let dolphin format later Dates
                 values.insert(role, (*rangeBegin).second);
             } else {


@@ -91,6 +122,18 @@ QHash<QByteArray, QVariant> KBalooRolesProvider::roleValues(const Baloo::File& f
         rangeBegin = rangeEnd;
     }
 
         rangeBegin = rangeEnd;
     }
 

+    if (roles.contains("dimensions")) {
+        bool widthOk = false;
+        bool heightOk = false;
+
+        const int width = propMap.value(KFileMetaData::Property::Width).toInt(&widthOk);
+        const int height = propMap.value(KFileMetaData::Property::Height).toInt(&heightOk);
+
+        if (widthOk && heightOk && width >= 0 && height >= 0) {
+            values.insert("dimensions", QSize(width, height));
+        }
+    }
+

     KFileMetaData::UserMetaData::Attributes attributes;
     if (roles.contains("tags")) {
         attributes |= KFileMetaData::UserMetaData::Tags;
     KFileMetaData::UserMetaData::Attributes attributes;
     if (roles.contains("tags")) {
         attributes |= KFileMetaData::UserMetaData::Tags;


@@ -130,41 +173,15 @@ QHash<QByteArray, QVariant> KBalooRolesProvider::roleValues(const Baloo::File& f
 
 KBalooRolesProvider::KBalooRolesProvider()
 {
 
 KBalooRolesProvider::KBalooRolesProvider()
 {

-    struct PropertyInfo
-    {
-        const char* const property;
-        const char* const role;
-    };
-
-    // Mapping from the URIs to the KFileItemModel roles. Note that this must not be
-    // a 1:1 mapping: One role may contain several URI-values
-    static const PropertyInfo propertyInfoList[] = {
-        { "rating", "rating" },
-        { "tag",        "tags" },
-        { "comment",   "comment" },
-        { "title",         "title" },
-        { "wordCount",     "wordCount" },
-        { "lineCount",     "lineCount" },
-        { "width",         "width" },
-        { "height",        "height" },
-        { "imageDateTime",   "imageDateTime"},
-        { "imageOrientation", "orientation", },
-        { "artist",     "artist" },
-        { "genre",     "genre"  },
-        { "album",    "album" },
-        { "duration",      "duration" },
-        { "bitRate", "bitrate" },
-        { "aspectRatio", "aspectRatio" },
-        { "frameRate", "frameRate" },
-        { "releaseYear",    "releaseYear" },
-        { "trackNumber",   "track" },
-        { "originUrl", "originUrl" }
-    };
-
-    for (unsigned int i = 0; i < sizeof(propertyInfoList) / sizeof(PropertyInfo); ++i) {
-        m_roleForProperty.insert(propertyInfoList[i].property, propertyInfoList[i].role);
-        m_roles.insert(propertyInfoList[i].role);
+    // Display roles filled from Baloo property cache
+    for (const auto &role : propertyRoleMap()) {
+        m_roles.insert(role);

     }
     }

+    m_roles.insert("dimensions");

 
 

+    // Display roles provided by UserMetaData
+    m_roles.insert(QByteArrayLiteral("tags"));
+    m_roles.insert(QByteArrayLiteral("rating"));
+    m_roles.insert(QByteArrayLiteral("comment"));
+    m_roles.insert(QByteArrayLiteral("originUrl"));

 }
 }

-