]> cloud.milkyroute.net Git - dolphin.git/blobdiff - src/views/dolphinview.cpp
projects / dolphin.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Delete obsolete class DolphinSettings
[dolphin.git] / src / views / dolphinview.cpp
diff --git a/src/views/dolphinview.cpp b/src/views/dolphinview.cpp
index f429529de131406b0f01197f95a58db3ab8c8378..9bb1d03db107db51dd4d254682102192759dffbe 100644 (file)
--- a/src/views/dolphinview.cpp
+++ b/src/views/dolphinview.cpp
@@ -22,16 +22,19 @@
 
 #include <QAbstractItemView>
 #include <QApplication>
 
 #include <QAbstractItemView>
 #include <QApplication>
+#include <QBoxLayout>
 #include <QClipboard>
 #include <QClipboard>
+#include <QDropEvent>
+#include <QGraphicsSceneDragDropEvent>
 #include <QKeyEvent>
 #include <QItemSelection>
 #include <QKeyEvent>
 #include <QItemSelection>
-#include <QBoxLayout>
 #include <QTimer>
 #include <QScrollBar>
 
 #include <KActionCollection>
 #include <KColorScheme>
 #include <KDirLister>
 #include <QTimer>
 #include <QScrollBar>
 
 #include <KActionCollection>
 #include <KColorScheme>
 #include <KDirLister>
+#include <KDirModel>
 #include <KIconEffect>
 #include <KFileItem>
 #include <KFileItemListProperties>
 #include <KIconEffect>
 #include <KFileItem>
 #include <KFileItemListProperties>
@@ -59,8 +62,9 @@
 #include "dolphin_detailsmodesettings.h"
 #include "dolphin_generalsettings.h"
 #include "dolphinitemlistcontainer.h"
 #include "dolphin_detailsmodesettings.h"
 #include "dolphin_generalsettings.h"
 #include "dolphinitemlistcontainer.h"
+#include "draganddrophelper.h"
 #include "renamedialog.h"
 #include "renamedialog.h"
-#include "settings/dolphinsettings.h"
+#include "versioncontrol/versioncontrolobserver.h"
 #include "viewmodecontroller.h"
 #include "viewproperties.h"
 #include "views/tooltips/tooltipmanager.h"
 #include "viewmodecontroller.h"
 #include "viewproperties.h"
 #include "views/tooltips/tooltipmanager.h"
@@ -85,10 +89,11 @@ DolphinView::DolphinView(const KUrl& url, QWidget* parent) :
     m_container(0),
     m_toolTipManager(0),
     m_selectionChangedTimer(0),
     m_container(0),
     m_toolTipManager(0),
     m_selectionChangedTimer(0),
-    m_currentItemIndex(-1),
+    m_currentItemUrl(),
     m_restoredContentsPosition(),
     m_createdItemUrl(),
     m_restoredContentsPosition(),
     m_createdItemUrl(),
-    m_selectedItems()
+    m_selectedUrls(),
+    m_versionControlObserver(0)
 {
     m_topLayout = new QVBoxLayout(this);
     m_topLayout->setSpacing(0);
 {
     m_topLayout = new QVBoxLayout(this);
     m_topLayout->setSpacing(0);
@@ -114,7 +119,7 @@ DolphinView::DolphinView(const KUrl& url, QWidget* parent) :
             this, SLOT(updateSortFoldersFirst(bool)));
     connect(m_dolphinViewController, SIGNAL(additionalInfoChanged(QList<DolphinView::AdditionalInfo>)),
             this, SLOT(updateAdditionalInfo(QList<DolphinView::AdditionalInfo>)));*/
             this, SLOT(updateSortFoldersFirst(bool)));
     connect(m_dolphinViewController, SIGNAL(additionalInfoChanged(QList<DolphinView::AdditionalInfo>)),
             this, SLOT(updateAdditionalInfo(QList<DolphinView::AdditionalInfo>)));*/
-    //connect(m_dolphinViewController, SIGNAL(itemTriggered(KFileItem)),
+    //connect(m_dolphinViewController, SIGNAL(itemActivated(KFileItem)),
     //        this, SLOT(triggerItem(KFileItem)));
     //connect(m_dolphinViewController, SIGNAL(tabRequested(KUrl)),
     //        this, SIGNAL(tabRequested(KUrl)));
     //        this, SLOT(triggerItem(KFileItem)));
     //connect(m_dolphinViewController, SIGNAL(tabRequested(KUrl)),
     //        this, SIGNAL(tabRequested(KUrl)));
@@ -145,7 +150,6 @@ DolphinView::DolphinView(const KUrl& url, QWidget* parent) :
 
     connect(m_dirLister, SIGNAL(redirection(KUrl,KUrl)), this, SLOT(slotRedirection(KUrl,KUrl)));
     connect(m_dirLister, SIGNAL(started(KUrl)),          this, SLOT(slotDirListerStarted(KUrl)));
 
     connect(m_dirLister, SIGNAL(redirection(KUrl,KUrl)), this, SLOT(slotRedirection(KUrl,KUrl)));
     connect(m_dirLister, SIGNAL(started(KUrl)),          this, SLOT(slotDirListerStarted(KUrl)));
-    connect(m_dirLister, SIGNAL(completed()),            this, SLOT(slotDirListerCompleted()));
     connect(m_dirLister, SIGNAL(refreshItems(QList<QPair<KFileItem,KFileItem> >)),
             this, SLOT(slotRefreshItems()));
 
     connect(m_dirLister, SIGNAL(refreshItems(QList<QPair<KFileItem,KFileItem> >)),
             this, SLOT(slotRefreshItems()));
 
@@ -158,17 +162,27 @@ DolphinView::DolphinView(const KUrl& url, QWidget* parent) :
     connect(m_dirLister, SIGNAL(itemsDeleted(KFileItemList)), this, SIGNAL(itemCountChanged()));
 
     m_container = new DolphinItemListContainer(m_dirLister, this);
     connect(m_dirLister, SIGNAL(itemsDeleted(KFileItemList)), this, SIGNAL(itemCountChanged()));
 
     m_container = new DolphinItemListContainer(m_dirLister, this);
-    QHash<QByteArray, int> visibleRoles;
-    visibleRoles.insert("name", 0);
-    m_container->setVisibleRoles(visibleRoles);
+    m_container->setVisibleRoles(QList<QByteArray>() << "name");
+    m_container->installEventFilter(this);
 
     KItemListController* controller = m_container->controller();
     controller->setSelectionBehavior(KItemListController::MultiSelection);
 
     KItemListController* controller = m_container->controller();
     controller->setSelectionBehavior(KItemListController::MultiSelection);
-    connect(controller, SIGNAL(itemClicked(int,Qt::MouseButton)),
-            this, SLOT(slotItemClicked(int,Qt::MouseButton)));
+    connect(controller, SIGNAL(itemActivated(int)),
+            this, SLOT(slotItemActivated(int)));
+    connect(controller, SIGNAL(itemMiddleClicked(int)), this, SLOT(slotItemMiddleClicked(int)));
+    connect(controller, SIGNAL(itemContextMenuRequested(int,QPointF)), this, SLOT(slotItemContextMenuRequested(int,QPointF)));
+    connect(controller, SIGNAL(viewContextMenuRequested(QPointF)), this, SLOT(slotViewContextMenuRequested(QPointF)));
+    connect(controller, SIGNAL(headerContextMenuRequested(QPointF)), this, SLOT(slotHeaderContextMenuRequested(QPointF)));
     connect(controller, SIGNAL(itemExpansionToggleClicked(int)), this, SLOT(slotItemExpansionToggleClicked(int)));
     connect(controller, SIGNAL(itemHovered(int)), this, SLOT(slotItemHovered(int)));
     connect(controller, SIGNAL(itemUnhovered(int)), this, SLOT(slotItemUnhovered(int)));
     connect(controller, SIGNAL(itemExpansionToggleClicked(int)), this, SLOT(slotItemExpansionToggleClicked(int)));
     connect(controller, SIGNAL(itemHovered(int)), this, SLOT(slotItemHovered(int)));
     connect(controller, SIGNAL(itemUnhovered(int)), this, SLOT(slotItemUnhovered(int)));
+    connect(controller, SIGNAL(itemDropEvent(int,QGraphicsSceneDragDropEvent*)), this, SLOT(slotItemDropEvent(int,QGraphicsSceneDragDropEvent*)));
+    connect(controller, SIGNAL(modelChanged(KItemModelBase*,KItemModelBase*)), this, SLOT(slotModelChanged(KItemModelBase*,KItemModelBase*)));
+
+    KFileItemModel* model = fileItemModel();
+    if (model) {
+        connect(model, SIGNAL(loadingCompleted()), this, SLOT(slotLoadingCompleted()));
+    }
 
     KItemListSelectionManager* selectionManager = controller->selectionManager();
     connect(selectionManager, SIGNAL(selectionChanged(QSet<int>,QSet<int>)),
 
     KItemListSelectionManager* selectionManager = controller->selectionManager();
     connect(selectionManager, SIGNAL(selectionChanged(QSet<int>,QSet<int>)),
@@ -176,6 +190,12 @@ DolphinView::DolphinView(const KUrl& url, QWidget* parent) :
 
     m_toolTipManager = new ToolTipManager(this);
 
 
     m_toolTipManager = new ToolTipManager(this);
 
+    m_versionControlObserver = new VersionControlObserver(this);
+    m_versionControlObserver->setModel(model);
+    connect(m_versionControlObserver, SIGNAL(infoMessage(QString)), this, SIGNAL(infoMessage(QString)));
+    connect(m_versionControlObserver, SIGNAL(errorMessage(QString)), this, SIGNAL(errorMessage(QString)));
+    connect(m_versionControlObserver, SIGNAL(operationCompletedMessage(QString)), this, SIGNAL(operationCompletedMessage(QString)));
+
     applyViewProperties();
     m_topLayout->addWidget(m_container);
 
     applyViewProperties();
     m_topLayout->addWidget(m_container);
 
@@ -246,19 +266,65 @@ DolphinView::Mode DolphinView::mode() const
     return m_mode;
 }
 
     return m_mode;
 }
 
+void DolphinView::setPreviewsShown(bool show)
+{
+    if (previewsShown() == show) {
+        return;
+    }
+
+    ViewProperties props(url());
+    props.setPreviewsShown(show);
+
+    m_container->setPreviewsShown(show);
+    emit previewsShownChanged(show);
+}
+
 bool DolphinView::previewsShown() const
 {
     return m_container->previewsShown();
 }
 
 bool DolphinView::previewsShown() const
 {
     return m_container->previewsShown();
 }
 
+void DolphinView::setHiddenFilesShown(bool show)
+{
+    if (m_dirLister->showingDotFiles() == show) {
+        return;
+    }
+
+    const KFileItemList itemList = selectedItems();
+    m_selectedUrls.clear();
+    m_selectedUrls = itemList.urlList();
+
+    ViewProperties props(url());
+    props.setHiddenFilesShown(show);
+
+    m_dirLister->setShowingDotFiles(show);
+    m_dirLister->emitChanges();
+    emit hiddenFilesShownChanged(show);
+}
+
 bool DolphinView::hiddenFilesShown() const
 {
     return m_dirLister->showingDotFiles();
 }
 
 bool DolphinView::hiddenFilesShown() const
 {
     return m_dirLister->showingDotFiles();
 }
 
-bool DolphinView::categorizedSorting() const
+void DolphinView::setGroupedSorting(bool grouped)
 {
 {
-    return false; //m_storedCategorizedSorting;
+    if (grouped == groupedSorting()) {
+        return;
+    }
+
+    ViewProperties props(url());
+    props.setGroupedSorting(grouped);
+    props.save();
+
+    m_container->controller()->model()->setGroupedSorting(grouped);
+
+    emit groupedSortingChanged(grouped);
+}
+
+bool DolphinView::groupedSorting() const
+{
+    return fileItemModel()->groupedSorting();
 }
 
 KFileItemList DolphinView::items() const
 }
 
 KFileItemList DolphinView::items() const
@@ -272,8 +338,11 @@ KFileItemList DolphinView::selectedItems() const
     const KItemListSelectionManager* selectionManager = m_container->controller()->selectionManager();
     const QSet<int> selectedIndexes = selectionManager->selectedItems();
 
     const KItemListSelectionManager* selectionManager = m_container->controller()->selectionManager();
     const QSet<int> selectedIndexes = selectionManager->selectedItems();
 
+    QList<int> sortedIndexes = selectedIndexes.toList();
+    qSort(sortedIndexes);
+
     KFileItemList selectedItems;
     KFileItemList selectedItems;
-    QSetIterator<int> it(selectedIndexes);
+    QListIterator<int> it(sortedIndexes);
     while (it.hasNext()) {
         const int index = it.next();
         selectedItems.append(model->fileItem(index));
     while (it.hasNext()) {
         const int index = it.next();
         selectedItems.append(model->fileItem(index));
@@ -289,21 +358,32 @@ int DolphinView::selectedItemsCount() const
 
 void DolphinView::markUrlsAsSelected(const QList<KUrl>& urls)
 {
 
 void DolphinView::markUrlsAsSelected(const QList<KUrl>& urls)
 {
-    foreach (const KUrl& url, urls) {
-        KFileItem item(KFileItem::Unknown, KFileItem::Unknown, url);
-        m_selectedItems.append(item);
-    }
+    m_selectedUrls = urls;
+}
+
+void DolphinView::markUrlAsCurrent(const KUrl& url)
+{
+    m_currentItemUrl = url;
 }
 
 void DolphinView::setItemSelectionEnabled(const QRegExp& pattern, bool enabled)
 {
 }
 
 void DolphinView::setItemSelectionEnabled(const QRegExp& pattern, bool enabled)
 {
-    Q_UNUSED(pattern);
-    Q_UNUSED(enabled);
-    /*const QItemSelection matchingIndexes = childrenMatchingPattern(QModelIndex(), pattern);
-    const QItemSelectionModel::SelectionFlags command = enabled
-                                                      ? QItemSelectionModel::Select
-                                                      : QItemSelectionModel::Deselect;
-    m_viewAccessor.itemView()->selectionModel()->select(matchingIndexes, command);*/
+    const KItemListSelectionManager::SelectionMode mode = enabled
+                                                        ? KItemListSelectionManager::Select
+                                                        : KItemListSelectionManager::Deselect;
+    const KFileItemModel* model = fileItemModel();
+    KItemListSelectionManager* selectionManager = m_container->controller()->selectionManager();
+
+    for (int index = 0; index < model->count(); index++) {
+        const KFileItem item = model->fileItem(index);
+        if (pattern.exactMatch(item.name())) {
+            // An alternative approach would be to store the matching items in a QSet<int> and
+            // select them in one go after the loop, but we'd need a new function
+            // KItemListSelectionManager::setSelected(QSet<int>, SelectionMode mode)
+            // for that.
+            selectionManager->setSelected(index, 1, mode);
+        }
+    }
 }
 
 void DolphinView::setZoomLevel(int level)
 }
 
 void DolphinView::setZoomLevel(int level)
@@ -329,8 +409,8 @@ void DolphinView::setSorting(Sorting sorting)
 
 DolphinView::Sorting DolphinView::sorting() const
 {
 
 DolphinView::Sorting DolphinView::sorting() const
 {
-    return DolphinView::SortByName;
-    //return m_viewAccessor.proxyModel()->sorting();
+    KItemModelBase* model = m_container->controller()->model();
+    return sortingForSortRole(model->sortRole());
 }
 
 void DolphinView::setSortOrder(Qt::SortOrder order)
 }
 
 void DolphinView::setSortOrder(Qt::SortOrder order)
@@ -342,7 +422,8 @@ void DolphinView::setSortOrder(Qt::SortOrder order)
 
 Qt::SortOrder DolphinView::sortOrder() const
 {
 
 Qt::SortOrder DolphinView::sortOrder() const
 {
-    return Qt::AscendingOrder; // m_viewAccessor.proxyModel()->sortOrder();
+    KItemModelBase* model = fileItemModel();
+    return model->sortOrder();
 }
 
 void DolphinView::setSortFoldersFirst(bool foldersFirst)
 }
 
 void DolphinView::setSortFoldersFirst(bool foldersFirst)
@@ -354,7 +435,8 @@ void DolphinView::setSortFoldersFirst(bool foldersFirst)
 
 bool DolphinView::sortFoldersFirst() const
 {
 
 bool DolphinView::sortFoldersFirst() const
 {
-    return true; // m_viewAccessor.proxyModel()->sortFoldersFirst();
+    KFileItemModel* model = fileItemModel();
+    return model->sortFoldersFirst();
 }
 
 void DolphinView::setAdditionalInfoList(const QList<AdditionalInfo>& info)
 }
 
 void DolphinView::setAdditionalInfoList(const QList<AdditionalInfo>& info)
@@ -380,7 +462,10 @@ void DolphinView::reload()
     QByteArray viewState;
     QDataStream saveStream(&viewState, QIODevice::WriteOnly);
     saveState(saveStream);
     QByteArray viewState;
     QDataStream saveStream(&viewState, QIODevice::WriteOnly);
     saveState(saveStream);
-    m_selectedItems= selectedItems();
+
+    const KFileItemList itemList = selectedItems();
+    m_selectedUrls.clear();
+    m_selectedUrls = itemList.urlList();
 
     setUrl(url());
     loadDirectory(url(), true);
 
     setUrl(url());
     loadDirectory(url(), true);
@@ -434,67 +519,64 @@ void DolphinView::calculateItemCount(int& fileCount,
 
 QString DolphinView::statusBarText() const
 {
 
 QString DolphinView::statusBarText() const
 {
-    QString text;
+    QString summary;
+    QString foldersText;
+    QString filesText;
+
     int folderCount = 0;
     int fileCount = 0;
     KIO::filesize_t totalFileSize = 0;
 
     if (hasSelection()) {
     int folderCount = 0;
     int fileCount = 0;
     KIO::filesize_t totalFileSize = 0;
 
     if (hasSelection()) {
-        // give a summary of the status of the selected files
+        // Give a summary of the status of the selected files
         const KFileItemList list = selectedItems();
         const KFileItemList list = selectedItems();
-        if (list.isEmpty()) {
-            // when an item is triggered, it is temporary selected but selectedItems()
-            // will return an empty list
-            return text;
-        }
-
-        KFileItemList::const_iterator it = list.begin();
-        const KFileItemList::const_iterator end = list.end();
-        while (it != end) {
-            const KFileItem& item = *it;
+        foreach (const KFileItem& item, list) {
             if (item.isDir()) {
                 ++folderCount;
             } else {
                 ++fileCount;
                 totalFileSize += item.size();
             }
             if (item.isDir()) {
                 ++folderCount;
             } else {
                 ++fileCount;
                 totalFileSize += item.size();
             }
-            ++it;
         }
 
         if (folderCount + fileCount == 1) {
         }
 
         if (folderCount + fileCount == 1) {
-            // if only one item is selected, show the filename
-            const QString name = list.first().text();
-            text = (folderCount == 1) ? i18nc("@info:status", "<filename>%1</filename> selected", name) :
-                                        i18nc("@info:status", "<filename>%1</filename> selected (%2)",
-                                              name, KIO::convertSize(totalFileSize));
+            // If only one item is selected, show the filename
+            filesText = i18nc("@info:status", "<filename>%1</filename> selected", list.first().text());
         } else {
         } else {
-            // at least 2 items are selected
-            const QString foldersText = i18ncp("@info:status", "1 Folder selected", "%1 Folders selected", folderCount);
-            const QString filesText = i18ncp("@info:status", "1 File selected", "%1 Files selected", fileCount);
-            if ((folderCount > 0) && (fileCount > 0)) {
-                text = i18nc("@info:status folders, files (size)", "%1, %2 (%3)",
-                             foldersText, filesText, KIO::convertSize(totalFileSize));
-            } else if (fileCount > 0) {
-                text = i18nc("@info:status files (size)", "%1 (%2)", filesText, KIO::convertSize(totalFileSize));
-            } else {
-                Q_ASSERT(folderCount > 0);
-                text = foldersText;
-            }
+            // At least 2 items are selected
+            foldersText = i18ncp("@info:status", "1 Folder selected", "%1 Folders selected", folderCount);
+            filesText = i18ncp("@info:status", "1 File selected", "%1 Files selected", fileCount);
         }
     } else {
         calculateItemCount(fileCount, folderCount, totalFileSize);
         }
     } else {
         calculateItemCount(fileCount, folderCount, totalFileSize);
-        text = KIO::itemsSummaryString(fileCount + folderCount,
-                                       fileCount, folderCount,
-                                       totalFileSize, true);
+        foldersText = i18ncp("@info:status", "1 Folder", "%1 Folders", folderCount);
+        filesText = i18ncp("@info:status", "1 File", "%1 Files", fileCount);
     }
 
     }
 
-    return text;
+    if (fileCount > 0 && folderCount > 0) {
+        summary = i18nc("@info:status folders, files (size)", "%1, %2 (%3)",
+                        foldersText, filesText, fileSizeText(totalFileSize));
+    } else if (fileCount > 0) {
+        summary = i18nc("@info:status files (size)", "%1 (%2)", filesText, fileSizeText(totalFileSize));
+    } else if (folderCount > 0) {
+        summary = foldersText;
+    }
+
+    return summary;
 }
 
 QList<QAction*> DolphinView::versionControlActions(const KFileItemList& items) const
 {
 }
 
 QList<QAction*> DolphinView::versionControlActions(const KFileItemList& items) const
 {
-    Q_UNUSED(items);
-    return QList<QAction*>(); //m_dolphinViewController->versionControlActions(items);
+    QList<QAction*> actions;
+
+    if (items.isEmpty()) {
+        const KFileItem item = fileItemModel()->rootItem();
+        actions = m_versionControlObserver->actions(KFileItemList() << item);
+    } else {
+        actions = m_versionControlObserver->actions(items);
+    }
+
+    return actions;
 }
 
 void DolphinView::setUrl(const KUrl& url)
 }
 
 void DolphinView::setUrl(const KUrl& url)
@@ -529,23 +611,13 @@ void DolphinView::selectAll()
 
 void DolphinView::invertSelection()
 {
 
 void DolphinView::invertSelection()
 {
-     KItemListSelectionManager* selectionManager = m_container->controller()->selectionManager();
-     const QSet<int> selectedItems = selectionManager->selectedItems();
-     QSet<int> invertedSelectedItems;
-
-     const int maxIndex = fileItemModel()->count() - 1;
-     for (int i = 0; i <= maxIndex; ++i) {
-         if (!selectedItems.contains(i)) {
-             invertedSelectedItems.insert(i);
-         }
-     }
-
-     selectionManager->setSelectedItems(invertedSelectedItems);
+    KItemListSelectionManager* selectionManager = m_container->controller()->selectionManager();
+    selectionManager->setSelected(0, fileItemModel()->count(), KItemListSelectionManager::Toggle);
 }
 
 void DolphinView::clearSelection()
 {
 }
 
 void DolphinView::clearSelection()
 {
-    //m_viewAccessor.itemView()->clearSelection();
+    m_container->controller()->selectionManager()->clearSelection();
 }
 
 void DolphinView::renameSelectedItems()
 }
 
 void DolphinView::renameSelectedItems()
@@ -620,90 +692,135 @@ void DolphinView::pasteIntoFolder()
     }
 }
 
     }
 }
 
-void DolphinView::setPreviewsShown(bool show)
+bool DolphinView::eventFilter(QObject* watched, QEvent* event)
 {
 {
-    if (previewsShown() == show) {
-        return;
-    }
+    switch (event->type()) {
+    case QEvent::FocusIn:
+        if (watched == m_container) {
+            setActive(true);
+        }
+        break;
 
 
-    ViewProperties props(url());
-    props.setPreviewsShown(show);
+    default:
+        break;
+    }
 
 
-    m_container->setPreviewsShown(show);
-    emit previewsShownChanged(show);
+    return QWidget::eventFilter(watched, event);
 }
 
 }
 
-void DolphinView::setHiddenFilesShown(bool show)
+void DolphinView::wheelEvent(QWheelEvent* event)
 {
 {
-    if (m_dirLister->showingDotFiles() == show) {
-        return;
-    }
-
-    m_selectedItems = selectedItems();
+    if (event->modifiers().testFlag(Qt::ControlModifier)) {
+        const int numDegrees = event->delta() / 8;
+        const int numSteps = numDegrees / 15;
 
 
-    ViewProperties props(url());
-    props.setHiddenFilesShown(show);
+        setZoomLevel(zoomLevel() + numSteps);
+        event->accept();
+    } else {
+        event->ignore();
+    }
+}
 
 
-    m_dirLister->setShowingDotFiles(show);
-    m_dirLister->emitChanges();
-    emit hiddenFilesShownChanged(show);
+void DolphinView::activate()
+{
+    setActive(true);
 }
 
 }
 
-void DolphinView::setCategorizedSorting(bool categorized)
+void DolphinView::slotItemActivated(int index)
 {
 {
-    if (categorized == categorizedSorting()) {
+    Q_UNUSED(index);
+
+    const KFileItemList items = selectedItems();
+    if (items.isEmpty()) {
         return;
     }
 
         return;
     }
 
-    ViewProperties props(url());
-    props.setCategorizedSorting(categorized);
-    props.save();
-
-    //m_viewAccessor.proxyModel()->setCategorizedModel(categorized);
-
-    emit categorizedSortingChanged(categorized);
+    if (items.count() == 1) {
+        emit itemActivated(items.at(0)); // caught by DolphinViewContainer or DolphinPart
+    } else {
+        foreach (const KFileItem& item, items) {
+            if (item.isDir()) {
+                emit tabRequested(item.url());
+            } else {
+                emit itemActivated(item);
+            }
+        }
+    }
 }
 
 }
 
-void DolphinView::mouseReleaseEvent(QMouseEvent* event)
+void DolphinView::slotItemMiddleClicked(int index)
 {
 {
-    QWidget::mouseReleaseEvent(event);
-    setActive(true);
+    const KFileItem item = fileItemModel()->fileItem(index);
+    if (item.isDir() || isTabsForFilesEnabled()) {
+        emit tabRequested(item.url());
+    }
 }
 
 }
 
-void DolphinView::contextMenuEvent(QContextMenuEvent* event)
+void DolphinView::slotItemContextMenuRequested(int index, const QPointF& pos)
 {
 {
-    Q_UNUSED(event);
-
-    const QPoint pos = m_container->mapFromGlobal(QCursor::pos());
-    const KItemListView* view = m_container->controller()->view();
-    if (view->itemAt(pos) < 0) {
-        // Only open the context-menu if the cursor is above the viewport
-        // (the context-menu for items is handled in slotItemClicked())
-        requestContextMenu(KFileItem(), url(), QList<QAction*>());
+    if (GeneralSettings::showToolTips()) {
+        m_toolTipManager->hideToolTip();
     }
     }
+    const KFileItem item = fileItemModel()->fileItem(index);
+    emit requestContextMenu(pos.toPoint(), item, url(), QList<QAction*>());
 }
 
 }
 
-void DolphinView::activate()
+void DolphinView::slotViewContextMenuRequested(const QPointF& pos)
 {
 {
-    setActive(true);
+    if (GeneralSettings::showToolTips()) {
+        m_toolTipManager->hideToolTip();
+    }
+    emit requestContextMenu(pos.toPoint(), KFileItem(), url(), QList<QAction*>());
 }
 
 }
 
-void DolphinView::slotItemClicked(int index, Qt::MouseButton button)
+void DolphinView::slotHeaderContextMenuRequested(const QPointF& pos)
 {
 {
-    const KFileItem item = fileItemModel()->fileItem(index);
+    QWeakPointer<KMenu> menu = new KMenu(QApplication::activeWindow());
 
 
-    if (button & Qt::LeftButton) {
-        emit itemTriggered(item); // caught by DolphinViewContainer or DolphinPart
-    } else if (button & Qt::MidButton) {
-        if (item.isDir() || isTabsForFilesEnabled()) {
-            emit tabRequested(item.url());
+    KItemListView* view = m_container->controller()->view();
+    const QSet<QByteArray> visibleRolesSet = view->visibleRoles().toSet();
+
+    // Add all roles to the menu that can be shown or hidden by the user
+    const AdditionalInfoAccessor& infoAccessor = AdditionalInfoAccessor::instance();
+    const QList<DolphinView::AdditionalInfo> keys = infoAccessor.keys();
+    foreach (const DolphinView::AdditionalInfo info, keys) {
+        const QByteArray& role = infoAccessor.role(info);
+        if (role != "name") {
+            const QString text = fileItemModel()->roleDescription(role);
+
+            QAction* action = menu.data()->addAction(text);
+            action->setCheckable(true);
+            action->setChecked(visibleRolesSet.contains(role));
+            action->setData(info);
         }
         }
-    } else if (button & Qt::RightButton) {
-        if (GeneralSettings::showToolTips()) {
-            m_toolTipManager->hideToolTip();
+    }
+
+    QAction* action = menu.data()->exec(pos.toPoint());
+    if (action) {
+        // Show or hide the selected role
+        const DolphinView::AdditionalInfo info =
+            static_cast<DolphinView::AdditionalInfo>(action->data().toInt());
+
+        ViewProperties props(url());
+        QList<DolphinView::AdditionalInfo> infoList = props.additionalInfoList();
+
+        const QByteArray selectedRole = infoAccessor.role(info);
+        QList<QByteArray> visibleRoles = view->visibleRoles();
+
+        if (action->isChecked()) {
+            const int index = keys.indexOf(info) + 1;
+            visibleRoles.insert(index, selectedRole);
+            infoList.insert(index, info);
+        } else {
+            visibleRoles.removeOne(selectedRole);
+            infoList.removeOne(info);
         }
         }
-        emit requestContextMenu(item, url(), QList<QAction*>());
+
+        view->setVisibleRoles(visibleRoles);
+        props.setAdditionalInfoList(infoList);
     }
     }
+
+    delete menu.data();
 }
 
 void DolphinView::slotItemExpansionToggleClicked(int index)
 }
 
 void DolphinView::slotItemExpansionToggleClicked(int index)
@@ -722,7 +839,7 @@ void DolphinView::slotItemHovered(int index)
     const KFileItem item = fileItemModel()->fileItem(index);
 
     if (GeneralSettings::showToolTips()) {
     const KFileItem item = fileItemModel()->fileItem(index);
 
     if (GeneralSettings::showToolTips()) {
-        QRectF itemRect = m_container->controller()->view()->itemBoundingRect(index);
+        QRectF itemRect = m_container->controller()->view()->itemRect(index);
         const QPoint pos = m_container->mapToGlobal(itemRect.topLeft().toPoint());
         itemRect.moveTo(pos);
 
         const QPoint pos = m_container->mapToGlobal(itemRect.topLeft().toPoint());
         itemRect.moveTo(pos);
 
@@ -741,6 +858,32 @@ void DolphinView::slotItemUnhovered(int index)
     emit requestItemInfo(KFileItem());
 }
 
     emit requestItemInfo(KFileItem());
 }
 
+void DolphinView::slotItemDropEvent(int index, QGraphicsSceneDragDropEvent* event)
+{
+    const KFileItem destItem = fileItemModel()->fileItem(index);
+
+    QDropEvent dropEvent(event->pos().toPoint(),
+                         event->possibleActions(),
+                         event->mimeData(),
+                         event->buttons(),
+                         event->modifiers());
+
+    DragAndDropHelper::dropUrls(destItem, url(), &dropEvent, this);
+}
+
+void DolphinView::slotModelChanged(KItemModelBase* current, KItemModelBase* previous)
+{
+    if (previous != 0) {
+        disconnect(previous, SIGNAL(loadingCompleted()), this, SLOT(slotLoadingCompleted()));
+    }
+
+    Q_ASSERT(qobject_cast<KFileItemModel*>(current));
+    connect(current, SIGNAL(loadingCompleted()), this, SLOT(slotLoadingCompleted()));
+
+    KFileItemModel* fileItemModel = static_cast<KFileItemModel*>(current);
+    m_versionControlObserver->setModel(fileItemModel);
+}
+
 void DolphinView::slotSelectionChanged(const QSet<int>& current, const QSet<int>& previous)
 {
     const int currentCount = current.count();
 void DolphinView::slotSelectionChanged(const QSet<int>& current, const QSet<int>& previous)
 {
     const int currentCount = current.count();
@@ -761,18 +904,6 @@ void DolphinView::emitSelectionChangedSignal()
     emit selectionChanged(selectedItems());
 }
 
     emit selectionChanged(selectedItems());
 }
 
-void DolphinView::openContextMenu(const QPoint& pos,
-                                  const QList<QAction*>& customActions)
-{
-    KFileItem item;
-    const int index = m_container->controller()->view()->itemAt(pos);
-    if (index >= 0) {
-        item = fileItemModel()->fileItem(index);
-    }
-
-    emit requestContextMenu(item, url(), customActions);
-}
-
 void DolphinView::dropUrls(const KFileItem& destItem,
                            const KUrl& destPath,
                            QDropEvent* event)
 void DolphinView::dropUrls(const KFileItem& destItem,
                            const KUrl& destPath,
                            QDropEvent* event)
@@ -799,7 +930,8 @@ void DolphinView::updateSortOrder(Qt::SortOrder order)
     ViewProperties props(url());
     props.setSortOrder(order);
 
     ViewProperties props(url());
     props.setSortOrder(order);
 
-    //m_viewAccessor.proxyModel()->setSortOrder(order);
+    KItemModelBase* model = fileItemModel();
+    model->setSortOrder(order);
 
     emit sortOrderChanged(order);
 }
 
     emit sortOrderChanged(order);
 }
@@ -809,7 +941,8 @@ void DolphinView::updateSortFoldersFirst(bool foldersFirst)
     ViewProperties props(url());
     props.setSortFoldersFirst(foldersFirst);
 
     ViewProperties props(url());
     props.setSortFoldersFirst(foldersFirst);
 
-    //m_viewAccessor.proxyModel()->setSortFoldersFirst(foldersFirst);
+    KFileItemModel* model = fileItemModel();
+    model->setSortFoldersFirst(foldersFirst);
 
     emit sortFoldersFirstChanged(foldersFirst);
 }
 
     emit sortFoldersFirstChanged(foldersFirst);
 }
@@ -831,34 +964,34 @@ bool DolphinView::isTabsForFilesEnabled() const
 
 bool DolphinView::itemsExpandable() const
 {
 
 bool DolphinView::itemsExpandable() const
 {
-    return false; //m_viewAccessor.itemsExpandable();
+    return m_mode == DetailsView;
 }
 
 void DolphinView::restoreState(QDataStream& stream)
 {
     // Restore the current item that had the keyboard focus
 }
 
 void DolphinView::restoreState(QDataStream& stream)
 {
     // Restore the current item that had the keyboard focus
-    stream >> m_currentItemIndex;
+    stream >> m_currentItemUrl;
 
     // Restore the view position
     stream >> m_restoredContentsPosition;
 
     // Restore expanded folders (only relevant for the details view - will be ignored by the view in other view modes)
 
     // Restore the view position
     stream >> m_restoredContentsPosition;
 
     // Restore expanded folders (only relevant for the details view - will be ignored by the view in other view modes)
-    QSet<KUrl> urlsToExpand;
-    stream >> urlsToExpand;
-    /*const DolphinDetailsViewExpander* expander = m_viewAccessor.setExpandedUrls(urlsToExpand);
-    if (expander) {
-        m_expanderActive = true;
-        connect (expander, SIGNAL(completed()), this, SLOT(slotLoadingCompleted()));
-    }
-    else {
-        m_expanderActive = false;
-    }*/
+    QSet<KUrl> urls;
+    stream >> urls;
+    fileItemModel()->restoreExpandedUrls(urls);
 }
 
 void DolphinView::saveState(QDataStream& stream)
 {
     // Save the current item that has the keyboard focus
 }
 
 void DolphinView::saveState(QDataStream& stream)
 {
     // Save the current item that has the keyboard focus
-    stream << m_container->controller()->selectionManager()->currentItem();
+    const int currentIndex = m_container->controller()->selectionManager()->currentItem();
+    if (currentIndex != -1) {
+        KFileItem item = fileItemModel()->fileItem(currentIndex);
+        KUrl currentItemUrl = item.url();
+        stream << currentItemUrl;
+    } else {
+        stream << KUrl();
+    }
 
     // Save view position
     const qreal x = m_container->horizontalScrollBar()->value();
 
     // Save view position
     const qreal x = m_container->horizontalScrollBar()->value();
@@ -866,7 +999,7 @@ void DolphinView::saveState(QDataStream& stream)
     stream << QPoint(x, y);
 
     // Save expanded folders (only relevant for the details view - the set will be empty in other view modes)
     stream << QPoint(x, y);
 
     // Save expanded folders (only relevant for the details view - the set will be empty in other view modes)
-    //stream << m_viewAccessor.expandedUrls();
+    stream << fileItemModel()->expandedUrls();
 }
 
 bool DolphinView::hasSelection() const
 }
 
 bool DolphinView::hasSelection() const
@@ -912,10 +1045,15 @@ void DolphinView::slotRedirection(const KUrl& oldUrl, const KUrl& newUrl)
 
 void DolphinView::updateViewState()
 {
 
 void DolphinView::updateViewState()
 {
-    if (m_currentItemIndex >= 0) {
+    if (m_currentItemUrl != KUrl()) {
         KItemListSelectionManager* selectionManager = m_container->controller()->selectionManager();
         KItemListSelectionManager* selectionManager = m_container->controller()->selectionManager();
-        selectionManager->setCurrentItem(m_currentItemIndex);
-        m_currentItemIndex =-1;
+        const int currentIndex = fileItemModel()->index(m_currentItemUrl);
+        if (currentIndex != -1) {
+            selectionManager->setCurrentItem(currentIndex);
+        } else {
+            selectionManager->setCurrentItem(0);
+        }
+        m_currentItemUrl = KUrl();
     }
 
     if (!m_restoredContentsPosition.isNull()) {
     }
 
     if (!m_restoredContentsPosition.isNull()) {
@@ -927,20 +1065,20 @@ void DolphinView::updateViewState()
         m_container->verticalScrollBar()->setValue(y);
     }
 
         m_container->verticalScrollBar()->setValue(y);
     }
 
-    if (!m_selectedItems.isEmpty()) {
+    if (!m_selectedUrls.isEmpty()) {
         KItemListSelectionManager* selectionManager = m_container->controller()->selectionManager();
         QSet<int> selectedItems = selectionManager->selectedItems();
         const KFileItemModel* model = fileItemModel();
 
         KItemListSelectionManager* selectionManager = m_container->controller()->selectionManager();
         QSet<int> selectedItems = selectionManager->selectedItems();
         const KFileItemModel* model = fileItemModel();
 
-        foreach (const KFileItem& selectedItem, m_selectedItems) {
-            const int index = model->index(selectedItem);
+        foreach (const KUrl& url, m_selectedUrls) {
+            const int index = model->index(url);
             if (index >= 0) {
                 selectedItems.insert(index);
             }
         }
 
         selectionManager->setSelectedItems(selectedItems);
             if (index >= 0) {
                 selectedItems.insert(index);
             }
         }
 
         selectionManager->setSelectedItems(selectedItems);
-        m_selectedItems.clear();
+        m_selectedUrls.clear();
     }
 }
 
     }
 }
 
@@ -966,7 +1104,7 @@ void DolphinView::slotDeleteFileFinished(KJob* job)
 void DolphinView::slotDirListerStarted(const KUrl& url)
 {
     // Disable the writestate temporary until it can be determined in a fast way
 void DolphinView::slotDirListerStarted(const KUrl& url)
 {
     // Disable the writestate temporary until it can be determined in a fast way
-    // in DolphinView::slotDirListerCompleted()
+    // in DolphinView::slotLoadingCompleted()
     if (m_isFolderWritable) {
         m_isFolderWritable = false;
         emit writeStateChanged(m_isFolderWritable);
     if (m_isFolderWritable) {
         m_isFolderWritable = false;
         emit writeStateChanged(m_isFolderWritable);
@@ -975,7 +1113,7 @@ void DolphinView::slotDirListerStarted(const KUrl& url)
     emit startedPathLoading(url);
 }
 
     emit startedPathLoading(url);
 }
 
-void DolphinView::slotDirListerCompleted()
+void DolphinView::slotLoadingCompleted()
 {
     // Update the view-state. This has to be done using a Qt::QueuedConnection
     // because the view might not be in its final state yet (the view also
 {
     // Update the view-state. This has to be done using a Qt::QueuedConnection
     // because the view might not be in its final state yet (the view also
@@ -1056,33 +1194,33 @@ void DolphinView::applyViewProperties()
         emit hiddenFilesShownChanged(hiddenFilesShown);
     }
 
         emit hiddenFilesShownChanged(hiddenFilesShown);
     }
 
-/*    m_storedCategorizedSorting = props.categorizedSorting();
-    const bool categorized = m_storedCategorizedSorting && supportsCategorizedSorting();
-    if (categorized != m_viewAccessor.proxyModel()->isCategorizedModel()) {
-        m_viewAccessor.proxyModel()->setCategorizedModel(categorized);
-        emit categorizedSortingChanged();
-    }*/
+    KFileItemModel* model = fileItemModel();
+
+    const bool groupedSorting = props.groupedSorting();
+    if (groupedSorting != model->groupedSorting()) {
+        model->setGroupedSorting(groupedSorting);
+        emit groupedSortingChanged(groupedSorting);
+    }
 
     const DolphinView::Sorting sorting = props.sorting();
 
     const DolphinView::Sorting sorting = props.sorting();
-    KItemModelBase* model = m_container->controller()->model();
     const QByteArray newSortRole = sortRoleForSorting(sorting);
     if (newSortRole != model->sortRole()) {
         model->setSortRole(newSortRole);
         emit sortingChanged(sorting);
     }
     const QByteArray newSortRole = sortRoleForSorting(sorting);
     if (newSortRole != model->sortRole()) {
         model->setSortRole(newSortRole);
         emit sortingChanged(sorting);
     }
-/*
+
     const Qt::SortOrder sortOrder = props.sortOrder();
     const Qt::SortOrder sortOrder = props.sortOrder();
-    if (sortOrder != m_viewAccessor.proxyModel()->sortOrder()) {
-        m_viewAccessor.proxyModel()->setSortOrder(sortOrder);
+    if (sortOrder != model->sortOrder()) {
+        model->setSortOrder(sortOrder);
         emit sortOrderChanged(sortOrder);
     }
 
     const bool sortFoldersFirst = props.sortFoldersFirst();
         emit sortOrderChanged(sortOrder);
     }
 
     const bool sortFoldersFirst = props.sortFoldersFirst();
-    if (sortFoldersFirst != m_viewAccessor.proxyModel()->sortFoldersFirst()) {
-        m_viewAccessor.proxyModel()->setSortFoldersFirst(sortFoldersFirst);
+    if (sortFoldersFirst != model->sortFoldersFirst()) {
+        model->setSortFoldersFirst(sortFoldersFirst);
         emit sortFoldersFirstChanged(sortFoldersFirst);
     }
         emit sortFoldersFirstChanged(sortFoldersFirst);
     }
-*/
+
     const QList<DolphinView::AdditionalInfo> infoList = props.additionalInfoList();
     if (infoList != m_additionalInfoList) {
         const QList<DolphinView::AdditionalInfo> previousList = m_additionalInfoList;
     const QList<DolphinView::AdditionalInfo> infoList = props.additionalInfoList();
     if (infoList != m_additionalInfoList) {
         const QList<DolphinView::AdditionalInfo> previousList = m_additionalInfoList;
@@ -1111,13 +1249,12 @@ void DolphinView::applyAdditionalInfoListToView()
 {
     const AdditionalInfoAccessor& infoAccessor = AdditionalInfoAccessor::instance();
 
 {
     const AdditionalInfoAccessor& infoAccessor = AdditionalInfoAccessor::instance();
 
-    QHash<QByteArray, int> visibleRoles;
-    visibleRoles.insert("name", 0);
+    QList<QByteArray> visibleRoles;
+    visibleRoles.reserve(m_additionalInfoList.count() + 1);
+    visibleRoles.append("name");
 
 
-    int index = 1;
     foreach (AdditionalInfo info, m_additionalInfoList) {
     foreach (AdditionalInfo info, m_additionalInfoList) {
-        visibleRoles.insert(infoAccessor.role(info), index);
-        ++index;
+        visibleRoles.append(infoAccessor.role(info));
     }
 
     m_container->setVisibleRoles(visibleRoles);
     }
 
     m_container->setVisibleRoles(visibleRoles);
@@ -1141,29 +1278,28 @@ void DolphinView::updateZoomLevel(int oldZoomLevel)
 
 KUrl::List DolphinView::simplifiedSelectedUrls() const
 {
 
 KUrl::List DolphinView::simplifiedSelectedUrls() const
 {
-    Q_ASSERT(false); // TODO
     KUrl::List urls;
     KUrl::List urls;
-/*
+
     const KFileItemList items = selectedItems();
     foreach (const KFileItem &item, items) {
         urls.append(item.url());
     }
 
     const KFileItemList items = selectedItems();
     foreach (const KFileItem &item, items) {
         urls.append(item.url());
     }
 
-
     if (itemsExpandable()) {
     if (itemsExpandable()) {
+        // TODO: Check if we still need KDirModel for this in KDE 5.0
         urls = KDirModel::simplifiedUrlList(urls);
         urls = KDirModel::simplifiedUrlList(urls);
-    }*/
+    }
 
     return urls;
 }
 
 QMimeData* DolphinView::selectionMimeData() const
 {
 
     return urls;
 }
 
 QMimeData* DolphinView::selectionMimeData() const
 {
-    /*const QAbstractItemView* view = m_viewAccessor.itemView();
-    Q_ASSERT((view) && (view->selectionModel()));
-    const QItemSelection selection = m_viewAccessor.proxyModel()->mapSelectionToSource(view->selectionModel()->selection());
-    return m_viewAccessor.dirModel()->mimeData(selection.indexes());*/
-    return 0;
+    const KFileItemModel* model = fileItemModel();
+    const KItemListSelectionManager* selectionManager = m_container->controller()->selectionManager();
+    const QSet<int> selectedIndexes = selectionManager->selectedItems();
+
+    return model->createMimeData(selectedIndexes);
 }
 
 void DolphinView::markPastedUrlsAsSelected(const QMimeData* mimeData)
 }
 
 void DolphinView::markPastedUrlsAsSelected(const QMimeData* mimeData)
@@ -1172,32 +1308,6 @@ void DolphinView::markPastedUrlsAsSelected(const QMimeData* mimeData)
     markUrlsAsSelected(urls);
 }
 
     markUrlsAsSelected(urls);
 }
 
-QItemSelection DolphinView::childrenMatchingPattern(const QModelIndex& parent, const QRegExp& pattern) const
-{
-    Q_UNUSED(parent);
-    Q_UNUSED(pattern);
-    QItemSelection matchingIndexes;
-    /*const DolphinSortFilterProxyModel* proxyModel = m_viewAccessor.proxyModel();
-    const DolphinModel* dolphinModel = m_viewAccessor.dirModel();
-
-    const int rowCount = proxyModel->rowCount(parent);
-
-    for (int row = 0; row < rowCount; ++row) {
-        QModelIndex index = proxyModel->index(row, 0, parent);
-        QModelIndex sourceIndex = proxyModel->mapToSource(index);
-
-        if (sourceIndex.isValid() && pattern.exactMatch(dolphinModel->data(sourceIndex).toString())) {
-            matchingIndexes += QItemSelectionRange(index);
-        }
-
-        if (proxyModel->hasChildren(index)) {
-            matchingIndexes += childrenMatchingPattern(index, pattern);
-        }
-    }*/
-
-    return matchingIndexes;
-}
-
 void DolphinView::updateWritableState()
 {
     const bool wasFolderWritable = m_isFolderWritable;
 void DolphinView::updateWritableState()
 {
     const bool wasFolderWritable = m_isFolderWritable;
@@ -1231,4 +1341,44 @@ QByteArray DolphinView::sortRoleForSorting(Sorting sorting) const
     return QByteArray();
 }
 
     return QByteArray();
 }
 
+DolphinView::Sorting DolphinView::sortingForSortRole(const QByteArray& sortRole) const
+{
+    static QHash<QByteArray, DolphinView::Sorting> sortHash;
+    if (sortHash.isEmpty()) {
+        sortHash.insert("name", SortByName);
+        sortHash.insert("size", SortBySize);
+        sortHash.insert("date", SortByDate);
+        sortHash.insert("permissions", SortByPermissions);
+        sortHash.insert("owner", SortByOwner);
+        sortHash.insert("group", SortByGroup);
+        sortHash.insert("type", SortByType);
+        sortHash.insert("destination", SortByDestination);
+        sortHash.insert("path", SortByPath);
+    }
+    return sortHash.value(sortRole);
+}
+
+QString DolphinView::fileSizeText(KIO::filesize_t fileSize)
+{
+    const KLocale* locale = KGlobal::locale();
+    const unsigned int multiplier = (locale->binaryUnitDialect() == KLocale::MetricBinaryDialect)
+                                    ? 1000 : 1024;
+
+    QString text;
+    if (fileSize < multiplier) {
+        // Show the size in bytes
+        text = locale->formatByteSize(fileSize, 0, KLocale::DefaultBinaryDialect, KLocale::UnitByte);
+    } else if (fileSize < multiplier * multiplier) {
+        // Show the size in kilobytes and always round up. This is done
+        // for consistency with the values shown e.g. in the "Size" column
+        // of the details-view.
+        fileSize += (multiplier / 2) - 1;
+        text = locale->formatByteSize(fileSize, 0, KLocale::DefaultBinaryDialect, KLocale::UnitKiloByte);
+    } else {
+        // Show the size in the best fitting unit having one decimal
+        text = locale->formatByteSize(fileSize, 1);
+    }
+    return text;
+}
+
 #include "dolphinview.moc"
 #include "dolphinview.moc"