X-Git-Url: https://cloud.milkyroute.net/gitweb/dolphin.git/blobdiff_plain/ebd0f1b06fdf94fc7be5c44a434dd6fc96a34e4a..abb6807645598e8117e98bbf232cd9cd90fe019a:/src/dolphinmodel.cpp

diff --git a/src/dolphinmodel.cpp b/src/dolphinmodel.cpp
index 819b37d2a..503c1086d 100644
--- a/src/dolphinmodel.cpp
+++ b/src/dolphinmodel.cpp
@@ -45,13 +45,16 @@
 #include <QList>
 #include <QSortFilterProxyModel>
 #include <QPainter>
+#include <QPersistentModelIndex>
 #include <QDir>
 #include <QFileInfo>
 
 const char* DolphinModel::m_others = I18N_NOOP2("@title:group Name", "Others");
 
-DolphinModel::DolphinModel(QObject* parent)
-    : KDirModel(parent)
+DolphinModel::DolphinModel(QObject* parent) :
+    KDirModel(parent),
+    m_hasVersionData(false),
+    m_revisionHash()
 {
 }
 
@@ -59,72 +62,110 @@ DolphinModel::~DolphinModel()
 {
 }
 
+bool DolphinModel::setData(const QModelIndex& index, const QVariant& value, int role)
+{
+    if ((index.column() == DolphinModel::Version) && (role == Qt::DecorationRole)) {
+        // TODO: remove data again when items are deleted...
+
+        const QPersistentModelIndex key = index;
+        const KVersionControlPlugin::VersionState state = static_cast<KVersionControlPlugin::VersionState>(value.toInt());
+        if (m_revisionHash.value(key, KVersionControlPlugin::UnversionedVersion) != state) {
+            if (!m_hasVersionData) {
+                connect(this, SIGNAL(rowsRemoved (const QModelIndex&, int, int)),
+                        this, SLOT(slotRowsRemoved(const QModelIndex&, int, int)));
+                m_hasVersionData = true;
+            }
+
+            m_revisionHash.insert(key, state);
+            emit dataChanged(index, index);
+            return true;
+        }
+    }
+
+    return KDirModel::setData(index, value, role);
+}
+
 QVariant DolphinModel::data(const QModelIndex& index, int role) const
 {
     switch (role) {
     case KCategorizedSortFilterProxyModel::CategoryDisplayRole:
         return displayRoleData(index);
+
     case KCategorizedSortFilterProxyModel::CategorySortRole:
         return sortRoleData(index);
+
+    case Qt::DecorationRole:
+        if (index.column() == DolphinModel::Version) {
+            return m_revisionHash.value(index, KVersionControlPlugin::UnversionedVersion);
+        }
+        break;
+
+    case Qt::DisplayRole:
+        if (index.column() == DolphinModel::Version) {
+            switch (m_revisionHash.value(index, KVersionControlPlugin::UnversionedVersion)) {
+            case KVersionControlPlugin::NormalVersion:
+                return i18nc("@item::intable", "Normal");
+            case KVersionControlPlugin::UpdateRequiredVersion:
+                return i18nc("@item::intable", "Update required");
+            case KVersionControlPlugin::LocallyModifiedVersion:
+                return i18nc("@item::intable", "Locally modified");
+            case KVersionControlPlugin::AddedVersion:
+                return i18nc("@item::intable", "Added");
+            case KVersionControlPlugin::RemovedVersion:
+                return i18nc("@item::intable", "Removed");
+            case KVersionControlPlugin::ConflictingVersion:
+                return i18nc("@item::intable", "Conflicting");
+            case KVersionControlPlugin::UnversionedVersion:
+            default:
+                return i18nc("@item::intable", "Unversioned");
+            }
+        }
+        break;
+
     default:
-        return KDirModel::data(index, role);
+        break;
     }
-}
 
-int DolphinModel::columnCount(const QModelIndex &parent) const
-{
-    return KDirModel::columnCount(parent) + (ExtraColumnCount - ColumnCount);
+    return KDirModel::data(index, role);
 }
 
-quint32 DolphinModel::ratingForIndex(const QModelIndex& index)
+QVariant DolphinModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
-#ifdef HAVE_NEPOMUK
-    quint32 rating = 0;
+    if ((orientation == Qt::Horizontal) && (role == Qt::DisplayRole)) {
+        if (section < KDirModel::ColumnCount) {
+            return KDirModel::headerData(section, orientation, role);
+        }
 
-    const DolphinModel* dolphinModel = static_cast<const DolphinModel*>(index.model());
-    KFileItem item = dolphinModel->itemForIndex(index);
-    if (!item.isNull()) {
-        const Nepomuk::Resource resource(item.url().url(), Soprano::Vocabulary::Xesam::File());
-        rating = resource.rating();
+        Q_ASSERT(section == DolphinModel::Version);
+        return i18nc("@title::column", "Version");
     }
-    return rating;
-#else
-    Q_UNUSED(index);
-    return 0;
-#endif
+    return QVariant();
 }
 
-QString DolphinModel::tagsForIndex(const QModelIndex& index)
+int DolphinModel::columnCount(const QModelIndex& parent) const
 {
-#ifdef HAVE_NEPOMUK
-    QString tagsString;
-
-    const DolphinModel* dolphinModel = static_cast<const DolphinModel*>(index.model());
-    KFileItem item = dolphinModel->itemForIndex(index);
-    if (!item.isNull()) {
-        const Nepomuk::Resource resource(item.url().url(), Soprano::Vocabulary::Xesam::File());
-        const QList<Nepomuk::Tag> tags = resource.tags();
-        QStringList stringList;
-        foreach (const Nepomuk::Tag& tag, tags) {
-            stringList.append(tag.label());
-        }
-        stringList.sort();
+    return KDirModel::columnCount(parent) + (ExtraColumnCount - ColumnCount);
+}
 
-        foreach (const QString& str, stringList) {
-            tagsString += str;
-            tagsString += ", ";
-        }
+void DolphinModel::clearVersionData()
+{
+    m_revisionHash.clear();
+    m_hasVersionData = false;
+}
+
+bool DolphinModel::hasVersionData() const
+{
+    return m_hasVersionData;
+}
 
-        if (!tagsString.isEmpty()) {
-            tagsString.resize(tagsString.size() - 2);
+void DolphinModel::slotRowsRemoved(const QModelIndex& parent, int start, int end)
+{
+    if (m_hasVersionData) {
+        const int column = parent.column();
+        for (int row = start; row <= end; ++row) {
+            m_revisionHash.remove(parent.child(row, column));
         }
     }
-
-    return tagsString;
-#else
-    Q_UNUSED(index);
-    return QString();
-#endif
 }
 
 QVariant DolphinModel::displayRoleData(const QModelIndex& index) const
@@ -176,11 +217,7 @@ QVariant DolphinModel::displayRoleData(const QModelIndex& index) const
                     }
                 }
 
-                if (!validCategory) {
-                    retString = validCategory ? *currA : i18nc("@title:group Name", m_others);
-                } else {
-                    retString = *currA;
-                }
+                retString = validCategory ? *currA : i18nc("@title:group Name", m_others);
             }
         }
         break;
@@ -328,23 +365,11 @@ QVariant DolphinModel::displayRoleData(const QModelIndex& index) const
         retString = item.mimeComment();
         break;
 
-#ifdef HAVE_NEPOMUK
-    case DolphinModel::Rating: {
-        const quint32 rating = ratingForIndex(index);
-        retString = QString::number(rating);
+    case DolphinModel::Version:
+        retString = "test";
         break;
     }
 
-    case DolphinModel::Tags: {
-        retString = tagsForIndex(index);
-        if (retString.isEmpty()) {
-            retString = i18nc("@title:group Tags", "Not yet tagged");
-        }
-        break;
-    }
-#endif
-    }
-
     return retString;
 }
 
@@ -364,7 +389,7 @@ QVariant DolphinModel::sortRoleData(const QModelIndex& index) const
         retVariant = data(index, KCategorizedSortFilterProxyModel::CategoryDisplayRole);
         if (retVariant == i18nc("@title:group Name", m_others)) {
             // assure that the "Others" group is always the last categorization
-            retVariant = QString(QChar(QChar::ReplacementCharacter));
+            retVariant = QString('Z').append(QChar::ReplacementCharacter);
         }
         break;
     }
@@ -418,18 +443,6 @@ QVariant DolphinModel::sortRoleData(const QModelIndex& index) const
         }
         break;
 
-#ifdef HAVE_NEPOMUK
-    case DolphinModel::Rating: {
-        retVariant = ratingForIndex(index);
-        break;
-    }
-
-    case DolphinModel::Tags: {
-        retVariant = tagsForIndex(index).count();
-        break;
-    }
-#endif
-
     default:
         break;
     }