#include "dolphinview.h"
-#include <klocale.h>
-#include <kdirmodel.h>
+#ifdef HAVE_NEPOMUK
+#include <config-nepomuk.h>
+#include <nepomuk/global.h>
+#include <nepomuk/resource.h>
+#endif
+
#include <kdatetime.h>
+#include <kdirmodel.h>
+#include <kfileitem.h>
+#include <klocale.h>
+#include <kurl.h>
#include <QtGui/QSortFilterProxyModel>
return retString;
}
- int column;
-
- switch (sortRole)
- {
- case DolphinView::SortByName: // KDirModel::Name
- column = KDirModel::Name;
- break;
- case DolphinView::SortBySize: // KDirModel::Size
- column = KDirModel::Size;
- break;
- case DolphinView::SortByDate: // KDirModel::ModifiedTime
- column = KDirModel::ModifiedTime;
- break;
- case DolphinView::SortByPermissions: // KDirModel::Permissions
- column = KDirModel::Permissions;
- break;
- case DolphinView::SortByOwner: // KDirModel::Owner
- column = KDirModel::Owner;
- break;
- case DolphinView::SortByGroup: // KDirModel::Group
- column = KDirModel::Group;
- break;
- case DolphinView::SortByType: // KDirModel::Type
- column = KDirModel::Type;
- break;
- default:
- column = KDirModel::Name;
- }
-
- // KDirModel checks columns to know to which role are
- // we talking about
- QModelIndex theIndex = index.model()->index(index.row(),
- column,
- index.parent());
-
- if (!theIndex.isValid()) {
- return retString;
- }
-
- QVariant data = theIndex.model()->data(theIndex, Qt::DisplayRole);
-
const KDirModel *dirModel = qobject_cast<const KDirModel*>(index.model());
KFileItem *item = dirModel->itemForIndex(index);
- int fileSize;
- KDateTime modifiedTime;
switch (sortRole)
{
case DolphinView::SortByName:
+ {
+ // KDirModel checks columns to know to which role are
+ // we talking about
+ QModelIndex theIndex = index.model()->index(index.row(),
+ KDirModel::Name,
+ index.parent());
+
+ if (!theIndex.isValid()) {
+ return retString;
+ }
+
+ QVariant data = theIndex.model()->data(theIndex, Qt::DisplayRole);
if (data.toString().size())
{
if (!item->isHidden() && data.toString().at(0).isLetter())
}
}
break;
+ }
case DolphinView::SortByDate:
+ {
+ KDateTime modifiedTime;
modifiedTime.setTime_t(item->time(KIO::UDS_MODIFICATION_TIME));
modifiedTime = modifiedTime.toLocalZone();
else
retString = i18n("More than a year");
break;
+ }
case DolphinView::SortByPermissions:
retString = item->permissionsString();
retString = item->group();
break;
- case DolphinView::SortBySize:
- fileSize = (item) ? item->size() : -1;
+ case DolphinView::SortBySize: {
+ const int fileSize = item ? item->size() : -1;
if (item && item->isDir()) {
retString = i18n("Folders");
} else if (fileSize < 5242880) {
retString = i18nc("Size", "Big");
}
break;
+ }
case DolphinView::SortByType:
retString = item->mimeComment();
break;
+
+#ifdef HAVE_NEPOMUK
+ case DolphinView::SortByRating: {
+ KFileItem* item = dirModel->itemForIndex(index);
+ if (item != 0) {
+ const Nepomuk::Resource resource(item->url().url(), Nepomuk::NFO::File());
+ const quint32 rating = resource.rating();
+ retString = i18np("1 star", "%1 stars", rating);
+ }
+ break;
+ }
+ case DolphinView::SortByTags:
+ break;
+#endif
}
return retString;
break;
case DolphinView::SortByType:
action = actionCollection()->action("by_type");
+ break;
+#ifdef HAVE_NEPOMUK
+ case DolphinView::SortByRating:
+ action = actionCollection()->action("by_rating");
+ break;
+ case DolphinView::SortByTags:
+ action = actionCollection()->action("by_tags");
+ break;
+#endif
default:
break;
}
m_activeViewContainer->view()->setSorting(DolphinView::SortByType);
}
+void DolphinMainWindow::sortByRating()
+{
+ m_activeViewContainer->view()->setSorting(DolphinView::SortByRating);
+}
+
+void DolphinMainWindow::sortByTags()
+{
+ m_activeViewContainer->view()->setSorting(DolphinView::SortByTags);
+}
+
void DolphinMainWindow::toggleSortOrder()
{
DolphinView* view = m_activeViewContainer->view();
sortByType->setText(i18n("By Type"));
connect(sortByType, SIGNAL(triggered()), this, SLOT(sortByType()));
+ KToggleAction* sortByRating = actionCollection()->add<KToggleAction>("by_rating");
+ sortByRating->setText(i18n("By Rating"));
+
+ KToggleAction* sortByTags = actionCollection()->add<KToggleAction>("by_tags");
+ sortByTags->setText(i18n("By Tags"));
+
+#ifdef HAVE_NEPOMUK
+ if (MetaDataWidget::metaDataAvailable()) {
+ connect(sortByRating, SIGNAL(triggered()), this, SLOT(sortByRating()));
+ connect(sortByTags, SIGNAL(triggered()), this, SLOT(sortByTags()));
+ }
+ else {
+ sortByRating->setEnabled(false);
+ sortByTags->setEnabled(false);
+ }
+#else
+ sortByRating->setEnabled(false);
+ sortByTags->setEnabled(false);
+#endif
+
QActionGroup* sortGroup = new QActionGroup(this);
sortGroup->addAction(sortByName);
sortGroup->addAction(sortBySize);
sortGroup->addAction(sortByOwner);
sortGroup->addAction(sortByGroup);
sortGroup->addAction(sortByType);
+ sortGroup->addAction(sortByRating);
+ sortGroup->addAction(sortByTags);
KToggleAction* sortDescending = actionCollection()->add<KToggleAction>("descending");
sortDescending->setText(i18n("Descending"));
#include "dolphinsortfilterproxymodel.h"
+#ifdef HAVE_NEPOMUK
+#include <config-nepomuk.h>
+#include <nepomuk/global.h>
+#include <nepomuk/resource.h>
+#endif
+
#include <kdirmodel.h>
#include <kfileitem.h>
#include <kdatetime.h>
-static const int dolphinMapSize = 7;
-static int dolphinViewToDirModelColumn[] =
-{
- KDirModel::Name, // DolphinView::SortByName
- KDirModel::Size, // DolphinView::SortBySize
- KDirModel::ModifiedTime, // DolphinView::SortByDate
- KDirModel::Permissions, // DolphinView::SortByPermissions
- KDirModel::Owner, // DolphinView::SortByOwner
- KDirModel::Group, // DolphinView::SortByGroup
- KDirModel::Type // DolphinView::SortByType
-};
-
-static DolphinView::Sorting dirModelColumnToDolphinView[] =
+static DolphinView::Sorting sortingTypeTable[] =
{
DolphinView::SortByName, // KDirModel::Name
DolphinView::SortBySize, // KDirModel::Size
DolphinView::SortByOwner, // KDirModel::Owner
DolphinView::SortByGroup, // KDirModel::Group
DolphinView::SortByType // KDirModel::Type
+#ifdef HAVE_NEPOMUK
+ , DolphinView::SortByRating
+ , DolphinView::SortByTags
+#endif
};
-
DolphinSortFilterProxyModel::DolphinSortFilterProxyModel(QObject* parent) :
KSortFilterProxyModel(parent),
- m_sortColumn(0),
m_sorting(DolphinView::SortByName),
m_sortOrder(Qt::AscendingOrder)
{
void DolphinSortFilterProxyModel::setSorting(DolphinView::Sorting sorting)
{
- // Update the sort column by mapping DolpginView::Sorting to
- // KDirModel::ModelColumns. We will keep the sortOrder.
- Q_ASSERT(static_cast<int>(sorting) >= 0 && static_cast<int>(sorting) < dolphinMapSize);
- sort(dolphinViewToDirModelColumn[static_cast<int>(sorting)],
- m_sortOrder);
+ // change the sorting column by keeping the current sort order
+ sort(sorting, m_sortOrder);
}
void DolphinSortFilterProxyModel::setSortOrder(Qt::SortOrder sortOrder)
{
// change the sort order by keeping the current column
- sort(dolphinViewToDirModelColumn[m_sorting], sortOrder);
+ sort(m_sorting, sortOrder);
}
void DolphinSortFilterProxyModel::sort(int column, Qt::SortOrder sortOrder)
{
- m_sortColumn = column;
+ m_sorting = sortingForColumn(column);
m_sortOrder = sortOrder;
- m_sorting = (column >= 0) && (column < dolphinMapSize) ?
- dirModelColumnToDolphinView[column] :
- DolphinView::SortByName;
- setSortRole(dirModelColumnToDolphinView[column]);
+ setSortRole(m_sorting);
KSortFilterProxyModel::sort(column, sortOrder);
}
DolphinView::Sorting DolphinSortFilterProxyModel::sortingForColumn(int column)
{
- if ((column >= 0) && (column < dolphinMapSize)) {
- return dirModelColumnToDolphinView[column];
- }
- return DolphinView::SortByName;
+ Q_ASSERT(column >= 0);
+ Q_ASSERT(column < static_cast<int>(sizeof(sortingTypeTable) / sizeof(DolphinView::Sorting)));
+ return sortingTypeTable[column];
}
bool DolphinSortFilterProxyModel::lessThanGeneralPurpose(const QModelIndex &left,
case DolphinView::SortByType: {
// If we are sorting by size, show folders first. We will sort them
- // correctly later
+ // correctly later.
if (leftFileItem->isDir() && !rightFileItem->isDir()) {
return true;
} else if (!leftFileItem->isDir() && rightFileItem->isDir()) {
return naturalCompare(leftFileItem->mimeComment().toLower(),
rightFileItem->mimeComment().toLower()) < 0;
}
+#ifdef HAVE_NEPOMUK
+ case DolphinView::SortByRating: {
+ const quint32 leftRating = ratingForIndex(left);
+ const quint32 rightRating = ratingForIndex(right);
+ return leftRating > rightRating;
+ }
+#endif
+ default:
+ break;
}
return false;
}
{
KDirModel* dirModel = static_cast<KDirModel*>(sourceModel());
- QVariant leftData = dirModel->data(left, dolphinViewToDirModelColumn[sortRole()]);
- QVariant rightData = dirModel->data(right, dolphinViewToDirModelColumn[sortRole()]);
-
- const KFileItem *leftFileItem = dirModel->itemForIndex(left);
- const KFileItem *rightFileItem = dirModel->itemForIndex(right);
+ const KFileItem* leftFileItem = dirModel->itemForIndex(left);
+ const KFileItem* rightFileItem = dirModel->itemForIndex(right);
- // On our priority, folders go above regular files
+ // On our priority, folders go above regular files.
if (leftFileItem->isDir() && !rightFileItem->isDir()) {
return true;
} else if (!leftFileItem->isDir() && rightFileItem->isDir()) {
}
// Hidden elements go before visible ones, if they both are
- // folders or files
+ // folders or files.
if (leftFileItem->isHidden() && !rightFileItem->isHidden()) {
return true;
} else if (!leftFileItem->isHidden() && rightFileItem->isHidden()) {
switch (sortRole()) {
case DolphinView::SortByName: {
- // So we are in the same priority, what counts now is their names
- QString leftValueString = leftData.toString();
- QString rightValueString = rightData.toString();
-
- return sortCaseSensitivity() ? (naturalCompare(leftValueString, rightValueString) < 0) :
- (naturalCompare(leftValueString.toLower(), rightValueString.toLower()) < 0);
+ // So we are in the same priority, what counts now is their names.
+ const QVariant leftData = dirModel->data(left, KDirModel::Name);
+ const QVariant rightData = dirModel->data(right, KDirModel::Name);
+ const QString leftValueString(leftData.toString());
+ const QString rightValueString(rightData.toString());
+
+ return sortCaseSensitivity() ?
+ (naturalCompare(leftValueString, rightValueString) < 0) :
+ (naturalCompare(leftValueString.toLower(), rightValueString.toLower()) < 0);
}
case DolphinView::SortBySize: {
// In the case they two have the same child items, we sort them by
// their names. So we have always everything ordered. We also check
- // if we are taking in count their cases
+ // if we are taking in count their cases.
if (leftCount == rightCount) {
return sortCaseSensitivity() ? (naturalCompare(leftFileItem->name(), rightFileItem->name()) < 0) :
(naturalCompare(leftFileItem->name().toLower(), rightFileItem->name().toLower()) < 0);
}
// If they had different number of items, we sort them depending
- // on how many items had each other
+ // on how many items had each other.
return leftCount < rightCount;
}
// If what we are measuring is two files and they have the same size,
- // sort them by their file names
+ // sort them by their file names.
if (leftFileItem->size() == rightFileItem->size()) {
return sortCaseSensitivity() ? (naturalCompare(leftFileItem->name(), rightFileItem->name()) < 0) :
(naturalCompare(leftFileItem->name().toLower(), rightFileItem->name().toLower()) < 0);
}
- // If their sizes are different, sort them by their sizes, as expected
+ // If their sizes are different, sort them by their sizes, as expected.
return leftFileItem->size() < rightFileItem->size();
}
return naturalCompare(leftFileItem->mimeComment(),
rightFileItem->mimeComment()) < 0;
}
+
+#ifdef HAVE_NEPOMUK
+ case DolphinView::SortByRating: {
+ const quint32 leftRating = ratingForIndex(left);
+ const quint32 rightRating = ratingForIndex(right);
+
+ if (leftRating == rightRating) {
+ return sortCaseSensitivity() ?
+ (naturalCompare(leftFileItem->name(), rightFileItem->name()) < 0) :
+ (naturalCompare(leftFileItem->name().toLower(), rightFileItem->name().toLower()) < 0);
+ }
+
+ return leftRating > rightRating;
+ }
+#endif
}
// We have set a SortRole and trust the ProxyModel to do
return QSortFilterProxyModel::lessThan(left, right);
}
+quint32 DolphinSortFilterProxyModel::ratingForIndex(const QModelIndex& index) const
+{
+#ifdef HAVE_NEPOMUK
+ quint32 rating = 0;
+
+ const KDirModel* dirModel = static_cast<const KDirModel*>(sourceModel());
+ KFileItem* item = dirModel->itemForIndex(index);
+ if (item != 0) {
+ const Nepomuk::Resource resource(item->url().url(), Nepomuk::NFO::File());
+ rating = resource.rating();
+ }
+ return rating;
+#else
+ Q_UNUSED(index);
+ return 0;
+#endif
+}
+
int DolphinSortFilterProxyModel::naturalCompare(const QString& a,
const QString& b)
{
projects / dolphin.git / commitdiff