Added old KDE3 version of dolphin

git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/applications/dolphin@1076309 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 789 insertions, 0 deletions

diff --git a/src/dolphindetailsview.cpp b/src/dolphindetailsview.cpp
new file mode 100644
index 0000000..66d524e
--- /dev/null
+++ b/src/dolphindetailsview.cpp
@@ -0,0 +1,789 @@
+/***************************************************************************
+ *   Copyright (C) 2006 by Peter Penz                                      *
+ *   peter.penz@gmx.at                                                     *
+ *                                                                         *
+ *   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 of the License, 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.                          *
+ *                                                                         *
+ *   You should have received a copy of the GNU General Public License     *
+ *   along with this program; if not, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.             *
+ ***************************************************************************/
+
+#include "dolphindetailsview.h"
+
+#include <kurldrag.h>
+#include <qpainter.h>
+#include <qobjectlist.h>
+#include <qheader.h>
+#include <qclipboard.h>
+#include <qpainter.h>
+#include <klocale.h>
+#include <kglobalsettings.h>
+#include <qscrollbar.h>
+#include <qcursor.h>
+#include <qstyle.h>
+#include <assert.h>
+
+#include "dolphinview.h"
+#include "viewproperties.h"
+#include "dolphin.h"
+#include "kiconeffect.h"
+#include "dolphinsettings.h"
+#include "dolphinstatusbar.h"
+#include "dolphindetailsviewsettings.h"
+
+DolphinDetailsView::DolphinDetailsView(DolphinView* parent) :
+    KFileDetailView(parent, 0),
+    m_dolphinView(parent),
+    m_resizeTimer(0),
+    m_scrollTimer(0),
+    m_rubber(0)
+{
+    m_resizeTimer = new QTimer(this);
+    connect(m_resizeTimer, SIGNAL(timeout()),
+            this, SLOT(updateColumnsWidth()));
+
+    setAcceptDrops(true);
+    setSelectionMode(KFile::Extended);
+    setHScrollBarMode(QScrollView::AlwaysOff);
+
+    setColumnAlignment(SizeColumn, Qt::AlignRight);
+    for (int i = DateColumn; i <= GroupColumn; ++i) {
+        setColumnAlignment(i, Qt::AlignHCenter);
+    }
+
+    Dolphin& dolphin = Dolphin::mainWin();
+
+    connect(this, SIGNAL(onItem(QListViewItem*)),
+            this, SLOT(slotOnItem(QListViewItem*)));
+    connect(this, SIGNAL(onViewport()),
+            this, SLOT(slotOnViewport()));
+    connect(this, SIGNAL(contextMenuRequested(QListViewItem*, const QPoint&, int)),
+            this, SLOT(slotContextMenuRequested(QListViewItem*, const QPoint&, int)));
+    connect(this, SIGNAL(selectionChanged()),
+            &dolphin, SLOT(slotSelectionChanged()));
+    connect(&dolphin, SIGNAL(activeViewChanged()),
+            this, SLOT(slotActivationUpdate()));
+    connect(this, SIGNAL(itemRenamed(QListViewItem*, const QString&, int)),
+            this, SLOT(slotItemRenamed(QListViewItem*, const QString&, int)));
+    connect(this, SIGNAL(dropped(QDropEvent*, const KURL::List&, const KURL&)),
+            parent, SLOT(slotURLListDropped(QDropEvent*, const KURL::List&, const KURL&)));
+
+    QClipboard* clipboard = QApplication::clipboard();
+    connect(clipboard, SIGNAL(dataChanged()),
+            this, SLOT(slotUpdateDisabledItems()));
+
+    QHeader* viewHeader = header();
+    viewHeader->setResizeEnabled(false);
+    viewHeader->setMovingEnabled(false);
+    connect(viewHeader, SIGNAL(clicked(int)),
+            this, SLOT(slotHeaderClicked(int)));
+
+    setMouseTracking(true);
+    setDefaultRenameAction(QListView::Accept);
+
+    refreshSettings();
+}
+
+DolphinDetailsView::~DolphinDetailsView()
+{
+    delete m_rubber;
+    m_rubber = 0;
+}
+
+void DolphinDetailsView::beginItemUpdates()
+{
+}
+
+void DolphinDetailsView::endItemUpdates()
+{
+    updateDisabledItems();
+
+    // Restore the current item. Use the information stored in the history if
+    // available. Otherwise use the first item as current item.
+
+    const KFileListViewItem* item = static_cast<const KFileListViewItem*>(firstChild());
+    if (item != 0) {
+        setCurrentItem(item->fileInfo());
+    }
+
+    int index = 0;
+    const QValueList<URLNavigator::HistoryElem> history = m_dolphinView->urlHistory(index);
+    if (!history.isEmpty()) {
+        KFileView* fileView = static_cast<KFileView*>(this);
+        fileView->setCurrentItem(history[index].currentFileName());
+        setContentsPos(history[index].contentsX(), history[index].contentsY());
+    }
+
+    updateColumnsWidth();
+}
+
+void DolphinDetailsView::insertItem(KFileItem* fileItem)
+{
+    KFileView::insertItem(fileItem);
+
+    DolphinListViewItem* item = new DolphinListViewItem(static_cast<QListView*>(this), fileItem);
+
+    QDir::SortSpec spec = KFileView::sorting();
+    if (spec & QDir::Time) {
+        item->setKey(sortingKey(fileItem->time(KIO::UDS_MODIFICATION_TIME),
+                                fileItem->isDir(),
+                                spec));
+    }
+    else if (spec & QDir::Size) {
+       item->setKey(sortingKey(fileItem->size(), fileItem->isDir(), spec));
+    }
+    else {
+       item->setKey(sortingKey(fileItem->text(), fileItem->isDir(), spec));
+    }
+
+    fileItem->setExtraData(this, item);
+}
+
+bool DolphinDetailsView::isOnFilename(const QListViewItem* item, const QPoint& pos) const
+{
+    const QPoint absPos(mapToGlobal(QPoint(0, 0)));
+    return (pos.x() - absPos.x()) <= filenameWidth(item);
+}
+
+void DolphinDetailsView::refreshSettings()
+{
+    const DolphinDetailsViewSettings* settings = DolphinSettings::instance().detailsView();
+    assert(settings != 0);
+
+    for (int i = DolphinDetailsView::GroupColumn; i >= DolphinDetailsView::NameColumn; --i) {
+        if (!settings->isColumnEnabled(i)) {
+            removeColumn(i);
+        }
+    }
+
+    QFont adjustedFont(font());
+    adjustedFont.setFamily(settings->fontFamily());
+    adjustedFont.setPointSize(settings->fontSize());
+    setFont(adjustedFont);
+
+    updateView(true);
+}
+
+void DolphinDetailsView::zoomIn()
+{
+    if (isZoomInPossible()) {
+        DolphinDetailsViewSettings* settings = DolphinSettings::instance().detailsView();
+        switch (settings->iconSize()) {
+            case KIcon::SizeSmall:  settings->setIconSize(KIcon::SizeMedium); break;
+            case KIcon::SizeMedium: settings->setIconSize(KIcon::SizeLarge); break;
+            default: assert(false); break;
+        }
+        ItemEffectsManager::zoomIn();
+    }
+}
+
+void DolphinDetailsView::zoomOut()
+{
+    if (isZoomOutPossible()) {
+        DolphinDetailsViewSettings* settings = DolphinSettings::instance().detailsView();
+        switch (settings->iconSize()) {
+            case KIcon::SizeLarge:  settings->setIconSize(KIcon::SizeMedium); break;
+            case KIcon::SizeMedium: settings->setIconSize(KIcon::SizeSmall); break;
+            default: assert(false); break;
+        }
+        ItemEffectsManager::zoomOut();
+    }
+}
+
+bool DolphinDetailsView::isZoomInPossible() const
+{
+    DolphinDetailsViewSettings* settings = DolphinSettings::instance().detailsView();
+    return settings->iconSize() < KIcon::SizeLarge;
+}
+
+bool DolphinDetailsView::isZoomOutPossible() const
+{
+    DolphinDetailsViewSettings* settings = DolphinSettings::instance().detailsView();
+    return settings->iconSize() > KIcon::SizeSmall;
+}
+
+void DolphinDetailsView::resizeContents(int width, int height)
+{
+    KFileDetailView::resizeContents(width, height);
+
+    // When loading several 1000 items a punch of resize events
+    // drops in. As updating the column width is a quite expensive
+    // operation, this operation will be postponed until there is
+    // no resize event for at least 50 milliseconds.
+    m_resizeTimer->stop();
+    m_resizeTimer->start(50, true);
+}
+
+void DolphinDetailsView::slotOnItem(QListViewItem* item)
+{
+    if (isOnFilename(item, QCursor::pos())) {
+        activateItem(item);
+        KFileItem* fileItem = static_cast<KFileListViewItem*>(item)->fileInfo();
+        m_dolphinView->requestItemInfo(fileItem->url());
+    }
+    else {
+        resetActivatedItem();
+    }
+}
+
+void DolphinDetailsView::slotOnViewport()
+{
+    resetActivatedItem();
+    m_dolphinView->requestItemInfo(KURL());
+}
+
+void DolphinDetailsView::setContextPixmap(void* context,
+                                        const QPixmap& pixmap)
+{
+    reinterpret_cast<KFileListViewItem*>(context)->setPixmap(0, pixmap);
+}
+
+const QPixmap* DolphinDetailsView::contextPixmap(void* context)
+{
+    return reinterpret_cast<KFileListViewItem*>(context)->pixmap(0);
+}
+
+void* DolphinDetailsView::firstContext()
+{
+    return reinterpret_cast<void*>(firstChild());
+}
+
+void* DolphinDetailsView::nextContext(void* context)
+{
+    KFileListViewItem* listViewItem = reinterpret_cast<KFileListViewItem*>(context);
+    return reinterpret_cast<void*>(listViewItem->nextSibling());
+}
+
+KFileItem* DolphinDetailsView::contextFileInfo(void* context)
+{
+    return reinterpret_cast<KFileListViewItem*>(context)->fileInfo();
+}
+
+
+void DolphinDetailsView::contentsDragMoveEvent(QDragMoveEvent* event)
+{
+    KFileDetailView::contentsDragMoveEvent(event);
+
+    // If a dragging is done above a directory, show the icon as 'active' for
+    // a visual feedback
+    KFileListViewItem* item = static_cast<KFileListViewItem*>(itemAt(event->pos()));
+
+    bool showActive = false;
+    if (item != 0) {
+        const KFileItem* fileInfo = item->fileInfo();
+        showActive = (fileInfo != 0) && fileInfo->isDir();
+    }
+
+    if (showActive) {
+        slotOnItem(item);
+    }
+    else {
+        slotOnViewport();
+    }
+}
+
+void DolphinDetailsView::resizeEvent(QResizeEvent* event)
+{
+    KFileDetailView::resizeEvent(event);
+
+    // When loading several 1000 items a punch of resize events
+    // drops in. As updating the column width is a quite expensive
+    // operation, this operation will be postponed until there is
+    // no resize event for at least 50 milliseconds.
+    m_resizeTimer->stop();
+    m_resizeTimer->start(50, true);
+}
+
+bool DolphinDetailsView::acceptDrag(QDropEvent* event) const
+{
+    bool accept = KURLDrag::canDecode(event) &&
+                  (event->action() == QDropEvent::Copy ||
+                   event->action() == QDropEvent::Move ||
+                   event->action() == QDropEvent::Link);
+    if (accept) {
+        if (static_cast<const QWidget*>(event->source()) == this) {
+            KFileListViewItem* item = static_cast<KFileListViewItem*>(itemAt(event->pos()));
+            accept = (item != 0);
+            if (accept) {
+                KFileItem* fileItem = item->fileInfo();
+                accept = fileItem->isDir();
+            }
+        }
+    }
+
+    return accept;
+}
+
+void DolphinDetailsView::contentsDropEvent(QDropEvent* event)
+{
+    // KFileDetailView::contentsDropEvent does not care whether the mouse
+    // cursor is above a filename or not, the destination URL is always
+    // the URL of the item. This is fixed here in a way that the destination
+    // URL is only the URL of the item if the cursor is above the filename.
+    const QPoint pos(QCursor::pos());
+    const QPoint viewportPos(viewport()->mapToGlobal(QPoint(0, 0)));
+    QListViewItem* item = itemAt(QPoint(pos.x() - viewportPos.x(), pos.y() - viewportPos.y()));
+    if ((item == 0) || ((item != 0) && isOnFilename(item, pos))) {
+        // dropping is done on the viewport or directly above a filename
+        KFileDetailView::contentsDropEvent(event);
+        return;
+    }
+
+    // Dropping is done above an item, but the mouse cursor is not above the file name.
+    // In this case the signals of the base implementation will be blocked and send
+    // in a corrected manner afterwards.
+    assert(item != 0);
+    const bool block = signalsBlocked();
+    blockSignals(true);
+    KFileDetailView::contentsDropEvent(event);
+    blockSignals(block);
+
+    if (!acceptDrag(event)) {
+        return;
+    }
+
+    emit dropped(event, 0);
+    KURL::List urls;
+    if (KURLDrag::decode(event, urls) && !urls.isEmpty()) {
+        emit dropped(event, urls, KURL());
+        sig->dropURLs(0, event, urls);
+    }
+}
+
+void DolphinDetailsView::contentsMousePressEvent(QMouseEvent* event)
+{
+    if (m_rubber != 0) {
+        drawRubber();
+        delete m_rubber;
+        m_rubber = 0;
+    }
+
+    // Swallow the base implementation of the mouse press event
+    // if the mouse cursor is not above the filename. This prevents
+    // that the item gets selected and simulates an equal usability
+    // like in the icon view.
+    const QPoint pos(QCursor::pos());
+    const QPoint viewportPos(viewport()->mapToGlobal(QPoint(0, 0)));
+    QListViewItem* item = itemAt(QPoint(pos.x() - viewportPos.x(), pos.y() - viewportPos.y()));
+    if ((item != 0) && isOnFilename(item, pos)) {
+        KFileDetailView::contentsMousePressEvent(event);
+    }
+    else if (event->button() == Qt::LeftButton) {
+        const ButtonState keyboardState = KApplication::keyboardMouseState();
+        const bool isSelectionActive = (keyboardState & ShiftButton) ||
+                                       (keyboardState & ControlButton);
+        if (!isSelectionActive) {
+            clearSelection();
+        }
+
+        assert(m_rubber == 0);
+        m_rubber = new QRect(event->x(), event->y(), 0, 0);
+    }
+
+    resetActivatedItem();
+    emit signalRequestActivation();
+
+    m_dolphinView->statusBar()->clear();
+}
+
+void DolphinDetailsView::contentsMouseMoveEvent(QMouseEvent* event)
+{
+    if (m_rubber != 0) {
+        slotAutoScroll();
+        return;
+    }
+
+    KFileDetailView::contentsMouseMoveEvent(event);
+
+    const QPoint& pos = event->globalPos();
+    const QPoint viewportPos = viewport()->mapToGlobal(QPoint(0, 0));
+    QListViewItem* item = itemAt(QPoint(pos.x() - viewportPos.x(), pos.y() - viewportPos.y()));
+    if ((item != 0) && isOnFilename(item, pos)) {
+        activateItem(item);
+    }
+    else {
+        resetActivatedItem();
+    }
+}
+
+void DolphinDetailsView::contentsMouseReleaseEvent(QMouseEvent* event)
+{
+    if (m_rubber != 0) {
+        drawRubber();
+        delete m_rubber;
+        m_rubber = 0;
+    }
+
+    if (m_scrollTimer != 0) {
+        disconnect(m_scrollTimer, SIGNAL(timeout()),
+                    this, SLOT(slotAutoScroll()));
+        m_scrollTimer->stop();
+        delete m_scrollTimer;
+        m_scrollTimer = 0;
+    }
+
+    KFileDetailView::contentsMouseReleaseEvent(event);
+}
+
+void DolphinDetailsView::paintEmptyArea(QPainter* painter, const QRect& rect)
+{
+    if (m_dolphinView->isActive()) {
+        KFileDetailView::paintEmptyArea(painter, rect);
+    }
+    else {
+        const QBrush brush(colorGroup().background());
+        painter->fillRect(rect, brush);
+    }
+}
+
+void DolphinDetailsView::drawRubber()
+{
+    // Parts of the following code have been taken
+    // from the class KonqBaseListViewWidget located in
+    // konqueror/listview/konq_listviewwidget.h of Konqueror.
+    // (Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
+    //  2001, 2002, 2004 Michael Brade <brade@kde.org>)
+    if (m_rubber == 0) {
+        return;
+    }
+
+    QPainter p;
+    p.begin(viewport());
+    p.setRasterOp(NotROP);
+    p.setPen(QPen(color0, 1));
+    p.setBrush(NoBrush);
+
+    QPoint point(m_rubber->x(), m_rubber->y());
+    point = contentsToViewport(point);
+    style().drawPrimitive(QStyle::PE_FocusRect, &p,
+                          QRect(point.x(), point.y(), m_rubber->width(), m_rubber->height()),
+                          colorGroup(), QStyle::Style_Default, colorGroup().base());
+    p.end();
+}
+
+void DolphinDetailsView::viewportPaintEvent(QPaintEvent* paintEvent)
+{
+    drawRubber();
+    KFileDetailView::viewportPaintEvent(paintEvent);
+    drawRubber();
+}
+
+void DolphinDetailsView::leaveEvent(QEvent* event)
+{
+    KFileDetailView::leaveEvent(event);
+    slotOnViewport();
+}
+
+void DolphinDetailsView::slotActivationUpdate()
+{
+    update();
+
+    // TODO: there must be a simpler way to say
+    // "update all children"
+    const QObjectList* list = children();
+    if (list == 0) {
+        return;
+    }
+
+    QObjectListIterator it(*list);
+    QObject* object = 0;
+    while ((object = it.current()) != 0) {
+        if (object->inherits("QWidget")) {
+            QWidget* widget = static_cast<QWidget*>(object);
+            widget->update();
+        }
+        ++it;
+    }
+}
+
+void DolphinDetailsView::slotContextMenuRequested(QListViewItem* item,
+                                                  const QPoint& pos,
+                                                  int /* col */)
+{
+    KFileItem* fileInfo = 0;
+    if ((item != 0) && isOnFilename(item, pos)) {
+        fileInfo = static_cast<KFileListViewItem*>(item)->fileInfo();
+    }
+    m_dolphinView->openContextMenu(fileInfo, pos);
+
+}
+
+void DolphinDetailsView::slotUpdateDisabledItems()
+{
+    updateDisabledItems();
+}
+
+void DolphinDetailsView::slotAutoScroll()
+{
+    // Parts of the following code have been taken
+    // from the class KonqBaseListViewWidget located in
+    // konqueror/listview/konq_listviewwidget.h of Konqueror.
+    // (Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
+    //  2001, 2002, 2004 Michael Brade <brade@kde.org>)
+
+    const QPoint pos(viewport()->mapFromGlobal(QCursor::pos()));
+    const QPoint vc(viewportToContents(pos));
+
+    if (vc == m_rubber->bottomRight()) {
+        return;
+    }
+
+    drawRubber();
+
+    m_rubber->setBottomRight(vc);
+
+    QListViewItem* item = itemAt(QPoint(0,0));
+
+    const bool block = signalsBlocked();
+    blockSignals(true);
+
+    const QRect rubber(m_rubber->normalize());
+    const int bottom = contentsY() + visibleHeight() - 1;
+
+    // select all items which intersect with the rubber, deselect all others
+    bool bottomReached = false;
+    while ((item != 0) && !bottomReached) {
+        QRect rect(itemRect(item));
+        rect.setWidth(filenameWidth(item));
+        rect = QRect(viewportToContents(rect.topLeft()),
+                     viewportToContents(rect.bottomRight()));
+        if (rect.isValid() && (rect.top() <= bottom)) {
+            const KFileItem* fileItem = static_cast<KFileListViewItem*>(item)->fileInfo();
+            setSelected(fileItem, rect.intersects(rubber));
+            item = item->itemBelow();
+        }
+        else {
+            bottomReached = true;
+        }
+    }
+
+    blockSignals(block);
+    emit selectionChanged();
+
+    drawRubber();
+
+    // scroll the viewport if the top or bottom margin is reached
+    const int scrollMargin = 40;
+    ensureVisible(vc.x(), vc.y(), scrollMargin, scrollMargin);
+    const bool scroll = !QRect(scrollMargin,
+                               scrollMargin,
+                               viewport()->width()  - 2 * scrollMargin,
+                               viewport()->height() - 2 * scrollMargin).contains(pos);
+    if (scroll) {
+        if (m_scrollTimer == 0) {
+            m_scrollTimer = new QTimer( this );
+            connect(m_scrollTimer, SIGNAL(timeout()),
+                    this, SLOT(slotAutoScroll()));
+            m_scrollTimer->start(100, false);
+        }
+    }
+    else if (m_scrollTimer != 0) {
+        disconnect(m_scrollTimer, SIGNAL(timeout()),
+                   this, SLOT(slotAutoScroll()));
+        m_scrollTimer->stop();
+        delete m_scrollTimer;
+        m_scrollTimer = 0;
+    }
+}
+
+void DolphinDetailsView::updateColumnsWidth()
+{
+    const int columnCount = columns();
+    int requiredWidth = 0;
+    for (int i = 1; i < columnCount; ++i) {
+        // When a directory contains no items, a minimum width for
+        // the column must be available, so that the header is readable.
+        // TODO: use header data instead of the hardcoded 64 value...
+        int columnWidth = 64;
+        QFontMetrics fontMetrics(font());
+        for (QListViewItem* item = firstChild(); item != 0; item = item->nextSibling()) {
+            const int width = item->width(fontMetrics, this, i);
+            if (width > columnWidth) {
+                columnWidth = width;
+            }
+        }
+        columnWidth += 16;    // add custom margin
+        setColumnWidth(i, columnWidth);
+        requiredWidth += columnWidth;
+    }
+
+    // resize the first column in a way that the
+    // whole available width is used
+    int firstColumnWidth = visibleWidth() - requiredWidth;
+    if (firstColumnWidth < 128) {
+        firstColumnWidth = 128;
+    }
+    setColumnWidth(0, firstColumnWidth);
+}
+
+void DolphinDetailsView::slotItemRenamed(QListViewItem* item,
+                                         const QString& name,
+                                         int /* column */)
+{
+    KFileItem* fileInfo = static_cast<KFileListViewItem*>(item)->fileInfo();
+    m_dolphinView->rename(KURL(fileInfo->url()), name);
+}
+
+void DolphinDetailsView::slotHeaderClicked(int /* section */)
+{
+    // The sorting has already been changed in QListView if this slot is
+    // invoked, but Dolphin was not informed about this (no signal is available
+    // which indicates a change of the sorting). This is bypassed by changing
+    // the sorting and sort order to a temporary other value and readjust it again.
+    const int column = sortColumn();
+    if (column <= DateColumn) {
+        DolphinView::Sorting sorting = DolphinView::SortByName;
+        switch (column) {
+            case SizeColumn: sorting = DolphinView::SortBySize; break;
+            case DateColumn: sorting = DolphinView::SortByDate; break;
+            case NameColumn:
+            default: break;
+        }
+
+        const Qt::SortOrder currSortOrder = sortOrder();
+
+        // temporary adjust the sorting and sort order to different values...
+        const DolphinView::Sorting tempSorting = (sorting == DolphinView::SortByName) ?
+                                                 DolphinView::SortBySize :
+                                                 DolphinView::SortByName;
+        m_dolphinView->setSorting(tempSorting);
+        const Qt::SortOrder tempSortOrder = (currSortOrder == Qt::Ascending) ?
+                                            Qt::Descending : Qt::Ascending;
+        m_dolphinView->setSortOrder(tempSortOrder);
+
+        // ... so that setting them again results in storing the new setting.
+        m_dolphinView->setSorting(sorting);
+        m_dolphinView->setSortOrder(currSortOrder);
+    }
+}
+
+DolphinDetailsView::DolphinListViewItem::DolphinListViewItem(QListView* parent,
+                                                             KFileItem* fileItem) :
+    KFileListViewItem(parent, fileItem)
+{
+    const int iconSize = DolphinSettings::instance().detailsView()->iconSize();
+    KFileItem* info = fileInfo();
+    setPixmap(DolphinDetailsView::NameColumn, info->pixmap(iconSize));
+
+    // The base class KFileListViewItem represents the column 'Size' only as byte values.
+    // Adjust those values in a way that a mapping to GBytes, MBytes, KBytes and Bytes
+    // is done. As the file size for directories is useless (only the size of the directory i-node
+    // is given), it is removed completely.
+    if (fileItem->isDir()) {
+        setText(SizeColumn, " - ");
+    }
+    else {
+        QString sizeText(KIO::convertSize(fileItem->size()));
+        sizeText.append(" ");
+        setText(SizeColumn, sizeText);
+    }
+
+    // Dolphin allows to remove specific columns, but the base class KFileListViewItem
+    // is not aware about this (or at least the class KFileDetailView does not react on
+    // QListView::remove()). Therefore the columns are rearranged here.
+    const DolphinDetailsViewSettings* settings = DolphinSettings::instance().detailsView();
+    assert(settings != 0);
+
+    int column_idx = DateColumn;    // the columns for 'name' and 'size' cannot get removed
+    for (int i = DolphinDetailsView::DateColumn; i <= DolphinDetailsView::GroupColumn; ++i) {
+        if (column_idx < i) {
+            setText(column_idx, text(i));
+        }
+        if (settings->isColumnEnabled(i)) {
+            ++column_idx;
+        }
+    }
+}
+
+DolphinDetailsView::DolphinListViewItem::~DolphinListViewItem()
+{
+}
+
+void DolphinDetailsView::DolphinListViewItem::paintCell(QPainter* painter,
+                                                        const QColorGroup& colorGroup,
+                                                        int column,
+                                                        int cellWidth,
+                                                        int alignment)
+{
+    const QListView* view = listView();
+    const bool isActive = view->parent() == Dolphin::mainWin().activeView();
+    if (isSelected()) {
+        // Per default the selection is drawn above the whole width of the item. As a consistent
+        // behavior with the icon view is wanted, only the the column containing the file name
+        // should be shown as selected.
+        QColorGroup defaultColorGroup(colorGroup);
+        const QColor highlightColor(isActive ? backgroundColor(column) : view->colorGroup().background());
+        defaultColorGroup.setColor(QColorGroup::Highlight , highlightColor);
+        defaultColorGroup.setColor(QColorGroup::HighlightedText, colorGroup.color(QColorGroup::Text));
+        KFileListViewItem::paintCell(painter, defaultColorGroup, column, cellWidth, alignment);
+
+        if (column == 0) {
+            // draw the selection only on the first column
+            QListView* parent = listView();
+            const int itemWidth = width(parent->fontMetrics(), parent, 0);
+            if (isActive) {
+                KFileListViewItem::paintCell(painter, colorGroup, column, itemWidth, alignment);
+            }
+            else {
+                QListViewItem::paintCell(painter, colorGroup, column, itemWidth, alignment);
+            }
+        }
+    }
+    else {
+        if (isActive) {
+            KFileListViewItem::paintCell(painter, colorGroup, column, cellWidth, alignment);
+        }
+        else {
+            QListViewItem::paintCell(painter, colorGroup, column, cellWidth, alignment);
+        }
+    }
+
+    if (column < listView()->columns() - 1) {
+        // draw a separator between columns
+        painter->setPen(KGlobalSettings::buttonBackground());
+        painter->drawLine(cellWidth - 1, 0, cellWidth - 1, height() - 1);
+    }
+}
+
+void DolphinDetailsView::DolphinListViewItem::paintFocus(QPainter* painter,
+                                                         const QColorGroup& colorGroup,
+                                                         const QRect& rect)
+{
+    // draw the focus consistently with the selection (see implementation notes
+    // in DolphinListViewItem::paintCell)
+    QListView* parent = listView();
+    int visibleWidth = width(parent->fontMetrics(), parent, 0);
+    const int colWidth = parent->columnWidth(0);
+    if (visibleWidth > colWidth) {
+        visibleWidth = colWidth;
+    }
+
+    QRect focusRect(rect);
+    focusRect.setWidth(visibleWidth);
+
+    KFileListViewItem::paintFocus(painter, colorGroup, focusRect);
+}
+
+int DolphinDetailsView::filenameWidth(const QListViewItem* item) const
+{
+    assert(item != 0);
+
+    int visibleWidth = item->width(fontMetrics(), this, 0);
+    const int colWidth = columnWidth(0);
+    if (visibleWidth > colWidth) {
+        visibleWidth = colWidth;
+    }
+
+    return visibleWidth;
+}
+#include "dolphindetailsview.moc"