Sourcecode hierarchy cleanup: Move further files from src to src/views

svn path=/trunk/KDE/kdebase/apps/; revision=1154150

24 files changed, 3431 insertions, 2 deletions

diff --git a/src/views/additionalinfoaccessor.cpp b/src/views/additionalinfoaccessor.cpp
new file mode 100644
index 000000000..1b445cc99
--- /dev/null
+++ b/src/views/additionalinfoaccessor.cpp
@@ -0,0 +1,132 @@
+/***************************************************************************
+ *   Copyright (C) 2010 by Peter Penz <[email protected]>             *
+ *                                                                         *
+ *   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 "additionalinfoaccessor.h"
+
+#include "dolphinmodel.h"
+#include <kglobal.h>
+#include <klocale.h>
+
+class AdditionalInfoAccessorSingleton
+{
+public:
+    AdditionalInfoAccessor instance;
+};
+K_GLOBAL_STATIC(AdditionalInfoAccessorSingleton, s_additionalInfoManager)
+
+AdditionalInfoAccessor& AdditionalInfoAccessor::instance()
+{
+    return s_additionalInfoManager->instance;
+}
+
+KFileItemDelegate::InformationList AdditionalInfoAccessor::keys() const
+{
+    return m_informations;
+}
+
+KFileItemDelegate::Information AdditionalInfoAccessor::keyForColumn(int columnIndex) const
+{
+    KFileItemDelegate::Information info = KFileItemDelegate::NoInformation;
+
+    switch (columnIndex) {
+    case DolphinModel::Size:           info = KFileItemDelegate::Size; break;
+    case DolphinModel::ModifiedTime:   info = KFileItemDelegate::ModificationTime; break;
+    case DolphinModel::Permissions:    info = KFileItemDelegate::Permissions; break;
+    case DolphinModel::Owner:          info = KFileItemDelegate::Owner; break;
+    case DolphinModel::Group:          info = KFileItemDelegate::OwnerAndGroup; break;
+    case DolphinModel::Type:           info = KFileItemDelegate::FriendlyMimeType; break;
+    case DolphinModel::LinkDest:       info = KFileItemDelegate::LinkDest; break;
+    case DolphinModel::LocalPathOrUrl: info = KFileItemDelegate::LocalPathOrUrl; break;
+    default: break;
+    }
+
+    return info;
+}
+
+QString AdditionalInfoAccessor::actionCollectionName(KFileItemDelegate::Information info,
+                                                     ActionCollectionType type) const
+{
+    QString name;
+    switch (type) {
+    case SortByType:
+        name = QLatin1String("sort_by_") + QLatin1String(m_map[info]->actionCollectionName);
+        break;
+
+    case AdditionalInfoType:
+        name = QLatin1String("show_") + QLatin1String(m_map[info]->actionCollectionName);
+        break;
+    }
+
+    return name;
+}
+
+QString AdditionalInfoAccessor::translation(KFileItemDelegate::Information info) const
+{
+    return i18nc(m_map[info]->context, m_map[info]->translation);
+}
+
+DolphinView::Sorting AdditionalInfoAccessor::sorting(KFileItemDelegate::Information info) const
+{
+    return m_map[info]->sorting;
+}
+
+int AdditionalInfoAccessor::bitValue(KFileItemDelegate::Information info) const
+{
+    return m_map[info]->bitValue;
+}
+
+AdditionalInfoAccessor::AdditionalInfoAccessor() :
+    m_informations(),
+    m_map()
+{
+    static const AdditionalInfoAccessor::AdditionalInfo additionalInfos[] = {
+        { "size",        I18N_NOOP2_NOSTRIP("@label", "Size"),             DolphinView::SortBySize,          1 },
+        { "date",        I18N_NOOP2_NOSTRIP("@label", "Date"),             DolphinView::SortByDate,          2 },
+        { "permissions", I18N_NOOP2_NOSTRIP("@label", "Permissions"),      DolphinView::SortByPermissions,   4 },
+        { "owner",       I18N_NOOP2_NOSTRIP("@label", "Owner"),            DolphinView::SortByOwner,         8 },
+        { "group",       I18N_NOOP2_NOSTRIP("@label", "Group"),            DolphinView::SortByGroup,        16 },
+        { "type",        I18N_NOOP2_NOSTRIP("@label", "Type"),             DolphinView::SortByType,         32 },
+        { "destination", I18N_NOOP2_NOSTRIP("@label", "Link Destination"), DolphinView::SortByDestination,  64 },
+        { "path",        I18N_NOOP2_NOSTRIP("@label", "Path"),             DolphinView::SortByPath,        128 }
+    };
+
+    m_map.insert(KFileItemDelegate::Size, &additionalInfos[0]);
+    m_map.insert(KFileItemDelegate::ModificationTime, &additionalInfos[1]);
+    m_map.insert(KFileItemDelegate::Permissions, &additionalInfos[2]);
+    m_map.insert(KFileItemDelegate::Owner, &additionalInfos[3]);
+    m_map.insert(KFileItemDelegate::OwnerAndGroup, &additionalInfos[4]);
+    m_map.insert(KFileItemDelegate::FriendlyMimeType, &additionalInfos[5]);
+    m_map.insert(KFileItemDelegate::LinkDest, &additionalInfos[6]);
+    m_map.insert(KFileItemDelegate::LocalPathOrUrl, &additionalInfos[7]);
+
+    // The m_informations list defines all available keys and the sort order
+    // (don't use m_informations = m_map.keys(), as the order is undefined).
+    m_informations.append(KFileItemDelegate::Size);
+    m_informations.append(KFileItemDelegate::ModificationTime);
+    m_informations.append(KFileItemDelegate::Permissions);
+    m_informations.append(KFileItemDelegate::Owner);
+    m_informations.append(KFileItemDelegate::OwnerAndGroup);
+    m_informations.append(KFileItemDelegate::FriendlyMimeType);
+    m_informations.append(KFileItemDelegate::LinkDest);
+    m_informations.append(KFileItemDelegate::LocalPathOrUrl);
+}
+
+AdditionalInfoAccessor::~AdditionalInfoAccessor()
+{
+}
diff --git a/src/views/additionalinfoaccessor.h b/src/views/additionalinfoaccessor.h
new file mode 100644
index 000000000..0a3d51459
--- /dev/null
+++ b/src/views/additionalinfoaccessor.h
@@ -0,0 +1,100 @@
+/***************************************************************************
+ *   Copyright (C) 2010 by Peter Penz <[email protected]>             *
+ *                                                                         *
+ *   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            *
+ ***************************************************************************/
+
+#ifndef ADDITIONALINFOACCESSOR_H
+#define ADDITIONALINFOACCESSOR_H
+
+#include <libdolphin_export.h>
+#include <kfileitemdelegate.h>
+#include <views/dolphinview.h>
+
+#include <QList>
+#include <QMap>
+
+/**
+ * @brief Allows to access the information that is available by KFileItemDelegate::Information.
+ *
+ * The information that is available by KFileItemDelegate::Information will be shown
+ * in Dolphin the following way:
+ * - As additional columns in the details view
+ * - As additional lines in the icons view
+ * - As menu entries in the "Sort By" and "Additional Information" groups
+ * - As popup menu entries in the details view header popup
+ * - As checkable entries in the View Properties dialog
+ *
+ * The AdditionalInfoAccessor provides a central place to get all available keys,
+ * the corresponding translations, action names, etc., so that modifications or
+ * extensions in KFileItemDelegate only require adjustments in the implementation
+ * of this class.
+ */
+class LIBDOLPHINPRIVATE_EXPORT AdditionalInfoAccessor
+{
+public:
+    enum ActionCollectionType {
+        /// Action collection from "View -> Sort By"
+        SortByType,
+        /// Action collection from "View -> Additional Information"
+        AdditionalInfoType
+    };
+
+    static AdditionalInfoAccessor& instance();
+
+    /**
+     * @return List of all available information entries of KFileItemDelegate.
+     *         All entries of this list are keys for accessing the corresponding
+     *         data (see actionCollectionName(), translation(), bitValue()).
+     */
+    KFileItemDelegate::InformationList keys() const;
+
+    /**
+     * @return Key for the model column with the index \p columnIndex.
+     */
+    KFileItemDelegate::Information keyForColumn(int columnIndex) const;
+
+    QString actionCollectionName(KFileItemDelegate::Information info, ActionCollectionType type) const;
+
+    QString translation(KFileItemDelegate::Information info) const;
+
+    DolphinView::Sorting sorting(KFileItemDelegate::Information info) const;
+
+    /**
+     * @return Bitvalue for \p info that is stored in a ViewProperties instance.
+     */
+    int bitValue(KFileItemDelegate::Information info) const;
+
+protected:
+    AdditionalInfoAccessor();
+    virtual ~AdditionalInfoAccessor();
+    friend class AdditionalInfoAccessorSingleton;
+
+private:
+    struct AdditionalInfo {
+        const char* const actionCollectionName;
+        const char* const context;
+        const char* const translation;
+        const DolphinView::Sorting sorting;
+        const int bitValue;
+    };
+
+    KFileItemDelegate::InformationList m_informations;
+    QMap<KFileItemDelegate::Information, const AdditionalInfo*> m_map;
+};
+
+#endif
+
diff --git a/src/views/dolphindirlister.cpp b/src/views/dolphindirlister.cpp
new file mode 100644
index 000000000..2eac5522d
--- /dev/null
+++ b/src/views/dolphindirlister.cpp
@@ -0,0 +1,48 @@
+/***************************************************************************
+ *   Copyright (C) 2006-2010 by Peter Penz <[email protected]>             *
+ *                                                                         *
+ *   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 "dolphindirlister.h"
+#include "klocale.h"
+#include <kio/jobclasses.h>
+
+DolphinDirLister::DolphinDirLister() :
+    KDirLister()
+{
+    setAutoErrorHandlingEnabled(false, 0);
+}
+
+DolphinDirLister::~DolphinDirLister()
+{
+}
+
+void DolphinDirLister::handleError(KIO::Job* job)
+{
+    if (job->error() == KIO::ERR_IS_FILE) {
+        emit urlIsFileError(url());
+    } else {
+        const QString errorString = job->errorString();
+        if (errorString.isEmpty()) {
+            emit errorMessage(i18nc("@info:status", "Unknown error."));
+        } else {
+            emit errorMessage(errorString);
+        }
+    }
+}
+
+#include "dolphindirlister.moc"
diff --git a/src/views/dolphindirlister.h b/src/views/dolphindirlister.h
new file mode 100644
index 000000000..629c335d3
--- /dev/null
+++ b/src/views/dolphindirlister.h
@@ -0,0 +1,48 @@
+/***************************************************************************
+ *   Copyright (C) 2006-2009 by Peter Penz <[email protected]>             *
+ *                                                                         *
+ *   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            *
+ ***************************************************************************/
+
+#ifndef DOLPHINDIRLISTER_H
+#define DOLPHINDIRLISTER_H
+
+#include <kdirlister.h>
+
+/**
+ * @brief Extends the class KDirLister by emitting a signal when an
+ *        error occurred instead of showing an error dialog.
+ */
+class DolphinDirLister : public KDirLister
+{
+    Q_OBJECT
+
+public:
+    DolphinDirLister();
+    virtual ~DolphinDirLister();
+
+signals:
+    /** Is emitted whenever an error has occurred. */
+    void errorMessage(const QString& msg);
+
+    /** Is emitted when the URL of the directory lister represents a file. */
+    void urlIsFileError(const KUrl& url);
+
+protected:
+    virtual void handleError(KIO::Job* job);
+};
+
+#endif
diff --git a/src/views/dolphinfileitemdelegate.cpp b/src/views/dolphinfileitemdelegate.cpp
index 17447d8cb..6b706c88b 100644
--- a/src/views/dolphinfileitemdelegate.cpp
+++ b/src/views/dolphinfileitemdelegate.cpp
@@ -19,7 +19,7 @@
 
 #include "dolphinfileitemdelegate.h"
 
-#include <dolphinmodel.h>
+#include "dolphinmodel.h"
 #include <kfileitem.h>
 #include <kicon.h>
 #include <kiconloader.h>
diff --git a/src/views/dolphinfileitemdelegate.h b/src/views/dolphinfileitemdelegate.h
index 405f24916..0777571f7 100644
--- a/src/views/dolphinfileitemdelegate.h
+++ b/src/views/dolphinfileitemdelegate.h
@@ -20,8 +20,8 @@
 #ifndef DOLPHINFILEITEMDELEGATE_H
 #define DOLPHINFILEITEMDELEGATE_H
 
-#include <dolphinmodel.h>
 #include <kfileitemdelegate.h>
+#include <views/dolphinmodel.h>
 
 class QAbstractProxyModel;
 
diff --git a/src/views/dolphinmodel.cpp b/src/views/dolphinmodel.cpp
new file mode 100644
index 000000000..137274e0d
--- /dev/null
+++ b/src/views/dolphinmodel.cpp
@@ -0,0 +1,445 @@
+/**
+  * This file is part of the KDE project
+  * Copyright (C) 2007 Rafael Fernández López <[email protected]>
+  *
+  * This library is free software; you can redistribute it and/or
+  * modify it under the terms of the GNU Library General Public
+  * License as published by the Free Software Foundation; either
+  * version 2 of the License, or (at your option) any later version.
+  *
+  * This library 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
+  * Library General Public License for more details.
+  *
+  * You should have received a copy of the GNU Library General Public License
+  * along with this library; see the file COPYING.LIB.  If not, write to
+  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+  * Boston, MA 02110-1301, USA.
+  */
+
+#include "dolphinmodel.h"
+
+#include "dolphinsortfilterproxymodel.h"
+
+#include "kcategorizedview.h"
+
+#include <kdatetime.h>
+#include <kdirmodel.h>
+#include <kfileitem.h>
+#include <kiconloader.h>
+#include <klocale.h>
+#include <kurl.h>
+#include <kuser.h>
+#include <kmimetype.h>
+#include <kstandarddirs.h>
+
+#include <QList>
+#include <QSortFilterProxyModel>
+#include <QPainter>
+#include <QPersistentModelIndex>
+#include <QDir>
+#include <QFileInfo>
+
+const char* const DolphinModel::m_others = I18N_NOOP2("@title:group Name", "Others");
+
+DolphinModel::DolphinModel(QObject* parent) :
+    KDirModel(parent),
+    m_hasVersionData(false),
+    m_revisionHash()
+{
+    setJobTransfersVisible(true);
+}
+
+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:
+        switch (index.column()) {
+        case DolphinModel::LinkDest: {
+            const KDirModel *dirModel = qobject_cast<const KDirModel*>(index.model());
+            const KFileItem item = dirModel->itemForIndex(index);
+            return item.linkDest();
+        }
+
+        case DolphinModel::LocalPathOrUrl:
+            const KDirModel *dirModel = qobject_cast<const KDirModel*>(index.model());
+            const KFileItem item = dirModel->itemForIndex(index);
+            return item.localPath();
+            break;
+        }
+        break;
+
+    default:
+        break;
+    }
+
+    return KDirModel::data(index, role);
+}
+
+QVariant DolphinModel::headerData(int section, Qt::Orientation orientation, int role) const
+{
+    if ((orientation == Qt::Horizontal) && (role == Qt::DisplayRole)) {
+        switch (section) {
+        case DolphinModel::LinkDest:
+            return i18nc("@title::column", "Link Destination");
+        case DolphinModel::LocalPathOrUrl:
+            return i18nc("@title::column", "Path");
+        default:
+            return KDirModel::headerData(section, orientation, role);
+        }
+    }
+    return QVariant();
+}
+
+int DolphinModel::columnCount(const QModelIndex& parent) const
+{
+    return KDirModel::columnCount(parent) + (ExtraColumnCount - ColumnCount);
+}
+
+void DolphinModel::clearVersionData()
+{
+    m_revisionHash.clear();
+    m_hasVersionData = false;
+}
+
+bool DolphinModel::hasVersionData() const
+{
+    return m_hasVersionData;
+}
+
+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));
+        }
+    }
+}
+
+QVariant DolphinModel::displayRoleData(const QModelIndex& index) const
+{
+    QString retString;
+
+    if (!index.isValid()) {
+        return retString;
+    }
+
+    const KDirModel *dirModel = qobject_cast<const KDirModel*>(index.model());
+    KFileItem item = dirModel->itemForIndex(index);
+
+    switch (index.column()) {
+    case KDirModel::Name: {
+        // KDirModel checks columns to know to which role are
+        // we talking about
+        const QModelIndex nameIndex = index.model()->index(index.row(), KDirModel::Name, index.parent());
+        if (!nameIndex.isValid()) {
+            return retString;
+        }
+        const QVariant data = nameIndex.model()->data(nameIndex, Qt::DisplayRole);
+        const QString name = data.toString();
+        if (!name.isEmpty()) {
+            if (!item.isHidden() && name.at(0).isLetter())
+                retString = name.at(0).toUpper();
+            else if (item.isHidden()) {
+                if (name.at(0) == '.') {
+                    if (name.size() > 1 && name.at(1).isLetter()) {
+                        retString = name.at(1).toUpper();
+                    } else {
+                        retString = i18nc("@title:group Name", m_others);
+                    }
+                } else {
+                    retString = name.at(0).toUpper();
+                }
+            } else {
+                bool validCategory = false;
+
+                const QString str(name.toUpper());
+                const QChar* currA = str.unicode();
+                while (!currA->isNull() && !validCategory) {
+                    if (currA->isLetter()) {
+                        validCategory = true;
+                    } else if (currA->isDigit()) {
+                        return i18nc("@title:group Name", m_others);
+                    } else {
+                        ++currA;
+                    }
+                }
+
+                retString = validCategory ? *currA : i18nc("@title:group Name", m_others);
+            }
+        }
+        break;
+    }
+
+    case KDirModel::Size: {
+        const KIO::filesize_t fileSize = !item.isNull() ? item.size() : ~0U;
+        if (!item.isNull() && item.isDir()) {
+            retString = i18nc("@title:group Size", "Folders");
+        } else if (fileSize < 5242880) {
+            retString = i18nc("@title:group Size", "Small");
+        } else if (fileSize < 10485760) {
+            retString = i18nc("@title:group Size", "Medium");
+        } else {
+            retString = i18nc("@title:group Size", "Big");
+        }
+        break;
+    }
+
+    case KDirModel::ModifiedTime: {
+        KDateTime modifiedTime = item.time(KFileItem::ModificationTime);
+        modifiedTime = modifiedTime.toLocalZone();
+
+        const QDate currentDate = KDateTime::currentLocalDateTime().date();
+        const QDate modifiedDate = modifiedTime.date();
+
+        const int daysDistance = modifiedDate.daysTo(currentDate);
+
+        int yearForCurrentWeek = 0;
+        int currentWeek = currentDate.weekNumber(&yearForCurrentWeek);
+        if (yearForCurrentWeek == currentDate.year() + 1) {
+            currentWeek = 53;
+        }
+
+        int yearForModifiedWeek = 0;
+        int modifiedWeek = modifiedDate.weekNumber(&yearForModifiedWeek);
+        if (yearForModifiedWeek == modifiedDate.year() + 1) {
+            modifiedWeek = 53;
+        }
+
+        if (currentDate.year() == modifiedDate.year() && currentDate.month() == modifiedDate.month()) {
+            if (modifiedWeek > currentWeek) {
+                // use case: modified date = 2010-01-01, current date = 2010-01-22
+                //           modified week = 53,         current week = 3
+                modifiedWeek = 0;
+            }
+            switch (currentWeek - modifiedWeek) {
+            case 0:
+                switch (daysDistance) {
+                case 0:  retString = i18nc("@title:group Date", "Today"); break;
+                case 1:  retString = i18nc("@title:group Date", "Yesterday"); break;
+                default: retString = modifiedTime.toString(i18nc("@title:group The week day name: %A", "%A"));
+                }
+                break;
+            case 1:
+                retString = i18nc("@title:group Date", "Last Week");
+                break;
+            case 2:
+                retString = i18nc("@title:group Date", "Two Weeks Ago");
+                break;
+            case 3:
+                retString = i18nc("@title:group Date", "Three Weeks Ago");
+                break;
+            case 4:
+            case 5:
+                retString = i18nc("@title:group Date", "Earlier this Month");
+                break;
+            default:
+                Q_ASSERT(false);
+            }
+        } else {
+            const QDate lastMonthDate = currentDate.addMonths(-1);
+            if  (lastMonthDate.year() == modifiedDate.year() && lastMonthDate.month() == modifiedDate.month()) {
+                if (daysDistance == 1) {
+                    retString = modifiedTime.toString(i18nc("@title:group Date: %B is full month name in current locale, and %Y is full year number", "Yesterday (%B, %Y)"));
+                } else if (daysDistance <= 7) {
+                    retString = modifiedTime.toString(i18nc("@title:group The week day name: %A, %B is full month name in current locale, and %Y is full year number", "%A (%B, %Y)"));
+                } else if (daysDistance <= 7 * 2) {
+                    retString = modifiedTime.toString(i18nc("@title:group Date: %B is full month name in current locale, and %Y is full year number", "Last Week (%B, %Y)"));
+                } else if (daysDistance <= 7 * 3) {
+                    retString = modifiedTime.toString(i18nc("@title:group Date: %B is full month name in current locale, and %Y is full year number", "Two Weeks Ago (%B, %Y)"));
+                } else if (daysDistance <= 7 * 4) {
+                    retString = modifiedTime.toString(i18nc("@title:group Date: %B is full month name in current locale, and %Y is full year number", "Three Weeks Ago (%B, %Y)"));
+                } else {
+                    retString = modifiedTime.toString(i18nc("@title:group Date: %B is full month name in current locale, and %Y is full year number", "Earlier on %B, %Y"));
+                }
+            } else {
+                retString = modifiedTime.toString(i18nc("@title:group The month and year: %B is full month name in current locale, and %Y is full year number", "%B, %Y"));
+            }
+        }
+        break;
+    }
+
+    case KDirModel::Permissions: {
+        QString user;
+        QString group;
+        QString others;
+
+        QFileInfo info(item.url().pathOrUrl());
+
+        // set user string
+        if (info.permission(QFile::ReadUser)) {
+            user = i18nc("@item:intext Access permission, concatenated", "Read, ");
+        }
+        if (info.permission(QFile::WriteUser)) {
+            user += i18nc("@item:intext Access permission, concatenated", "Write, ");
+        }
+        if (info.permission(QFile::ExeUser)) {
+            user += i18nc("@item:intext Access permission, concatenated", "Execute, ");
+        }
+        user = user.isEmpty() ? i18nc("@item:intext Access permission, concatenated", "Forbidden") : user.mid(0, user.count() - 2);
+
+        // set group string
+        if (info.permission(QFile::ReadGroup)) {
+            group = i18nc("@item:intext Access permission, concatenated", "Read, ");
+        }
+        if (info.permission(QFile::WriteGroup)) {
+            group += i18nc("@item:intext Access permission, concatenated", "Write, ");
+        }
+        if (info.permission(QFile::ExeGroup)) {
+            group += i18nc("@item:intext Access permission, concatenated", "Execute, ");
+        }
+        group = group.isEmpty() ? i18nc("@item:intext Access permission, concatenated", "Forbidden") : group.mid(0, group.count() - 2);
+
+        // set permission string
+        if (info.permission(QFile::ReadOther)) {
+            others = i18nc("@item:intext Access permission, concatenated", "Read, ");
+        }
+        if (info.permission(QFile::WriteOther)) {
+            others += i18nc("@item:intext Access permission, concatenated", "Write, ");
+        }
+        if (info.permission(QFile::ExeOther)) {
+            others += i18nc("@item:intext Access permission, concatenated", "Execute, ");
+        }
+        others = others.isEmpty() ? i18nc("@item:intext Access permission, concatenated", "Forbidden") : others.mid(0, others.count() - 2);
+
+        retString = i18nc("@title:group Files and folders by permissions", "(User: %1) (Group: %2) (Others: %3)", user, group, others);
+        break;
+    }
+
+    case KDirModel::Owner:
+        retString = item.user();
+        break;
+
+    case KDirModel::Group:
+        retString = item.group();
+        break;
+
+    case KDirModel::Type:
+        retString = item.mimeComment();
+        break;
+
+    case DolphinModel::Version:
+        retString = "test";
+        break;
+    }
+
+    return retString;
+}
+
+QVariant DolphinModel::sortRoleData(const QModelIndex& index) const
+{
+    QVariant retVariant;
+
+    if (!index.isValid()) {
+        return retVariant;
+    }
+
+    const KDirModel *dirModel = qobject_cast<const KDirModel*>(index.model());
+    KFileItem item = dirModel->itemForIndex(index);
+
+    switch (index.column()) {
+    case KDirModel::Name: {
+        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('Z').append(QChar::ReplacementCharacter);
+        }
+        break;
+    }
+
+    case KDirModel::Size: {
+        const KIO::filesize_t fileSize = !item.isNull() ? item.size() : ~0U;
+        if (item.isDir()) {
+            retVariant = 0;
+        } else if (fileSize < 5242880) {
+            retVariant = 1;
+        } else if (fileSize < 10485760) {
+            retVariant = 2;
+        } else {
+            retVariant = 3;
+        }
+        break;
+    }
+
+    case KDirModel::ModifiedTime: {
+        KDateTime modifiedTime = item.time(KFileItem::ModificationTime);
+        modifiedTime = modifiedTime.toLocalZone();
+
+        const QDate currentDate = KDateTime::currentLocalDateTime().date();
+        const QDate modifiedDate = modifiedTime.date();
+
+        retVariant = -modifiedDate.daysTo(currentDate);
+        break;
+    }
+
+    case KDirModel::Permissions: {
+        QFileInfo info(item.url().pathOrUrl());
+
+        retVariant = -KDirSortFilterProxyModel::pointsForPermissions(info);
+        break;
+    }
+
+    case KDirModel::Owner:
+        retVariant = item.user();
+        break;
+
+    case KDirModel::Group:
+        retVariant = item.group();
+        break;
+
+    case KDirModel::Type:
+        if (item.isDir()) {
+            // when sorting we want folders to be placed first
+            retVariant = QString(); // krazy:exclude=nullstrassign
+        } else {
+            retVariant = item.mimeComment();
+        }
+        break;
+
+    default:
+        break;
+    }
+
+    return retVariant;
+}
diff --git a/src/views/dolphinmodel.h b/src/views/dolphinmodel.h
new file mode 100644
index 000000000..6f1b00c75
--- /dev/null
+++ b/src/views/dolphinmodel.h
@@ -0,0 +1,68 @@
+/*
+  * This file is part of the KDE project
+  * Copyright (C) 2007 Rafael Fernández López <[email protected]>
+  *
+  * This library is free software; you can redistribute it and/or
+  * modify it under the terms of the GNU Library General Public
+  * License as published by the Free Software Foundation; either
+  * version 2 of the License, or (at your option) any later version.
+  *
+  * This library 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
+  * Library General Public License for more details.
+  *
+  * You should have received a copy of the GNU Library General Public License
+  * along with this library; see the file COPYING.LIB.  If not, write to
+  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+  * Boston, MA 02110-1301, USA.
+*/
+
+#ifndef DOLPHINMODEL_H
+#define DOLPHINMODEL_H
+
+#include <kdirmodel.h>
+#include <kversioncontrolplugin.h>
+#include <libdolphin_export.h>
+
+#include <QHash>
+#include <QPersistentModelIndex>
+
+class LIBDOLPHINPRIVATE_EXPORT DolphinModel : public KDirModel
+{
+    Q_OBJECT
+
+public:
+    enum AdditionalColumns {
+        Version = KDirModel::ColumnCount,
+        LinkDest,
+        LocalPathOrUrl,
+        ExtraColumnCount // Mandatory last entry
+    };
+
+    DolphinModel(QObject* parent = 0);
+    virtual ~DolphinModel();
+
+    virtual bool setData(const QModelIndex& index, const QVariant& value, int role = Qt::EditRole);
+    virtual QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const;
+    virtual QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const;
+    virtual int columnCount(const QModelIndex& parent = QModelIndex()) const;
+
+    void clearVersionData();
+    bool hasVersionData() const;
+
+private slots:
+    void slotRowsRemoved(const QModelIndex& parent, int start, int end);
+
+private:
+    QVariant displayRoleData(const QModelIndex& index) const;
+    QVariant sortRoleData(const QModelIndex& index) const;
+
+private:
+    bool m_hasVersionData;
+    QHash<QPersistentModelIndex, KVersionControlPlugin::VersionState> m_revisionHash;
+
+    static const char* const m_others;
+};
+
+#endif // DOLPHINMODEL_H
diff --git a/src/views/dolphinnewmenuobserver.cpp b/src/views/dolphinnewmenuobserver.cpp
new file mode 100644
index 000000000..def510c53
--- /dev/null
+++ b/src/views/dolphinnewmenuobserver.cpp
@@ -0,0 +1,62 @@
+/***************************************************************************
+ *   Copyright (C) 2009 by Peter Penz <[email protected]>                  *
+ *                                                                         *
+ *   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 "dolphinnewmenuobserver.h"
+
+#include <kglobal.h>
+#include <knewmenu.h>
+
+class DolphinNewMenuObserverSingleton
+{
+public:
+    DolphinNewMenuObserver instance;
+};
+K_GLOBAL_STATIC(DolphinNewMenuObserverSingleton, s_dolphinNewMenuObserver)
+
+DolphinNewMenuObserver& DolphinNewMenuObserver::instance()
+{
+    return s_dolphinNewMenuObserver->instance;
+}
+
+void DolphinNewMenuObserver::attach(const KNewFileMenu* menu)
+{
+    connect(menu, SIGNAL(fileCreated(const KUrl&)),
+            this, SIGNAL(itemCreated(const KUrl&)));
+    connect(menu, SIGNAL(directoryCreated(const KUrl&)),
+            this, SIGNAL(itemCreated(const KUrl&)));
+}
+
+void DolphinNewMenuObserver::detach(const KNewFileMenu* menu)
+{
+    disconnect(menu, SIGNAL(fileCreated(const KUrl&)),
+               this, SIGNAL(itemCreated(const KUrl&)));
+    disconnect(menu, SIGNAL(directoryCreated(const KUrl&)),
+               this, SIGNAL(itemCreated(const KUrl&)));
+}
+
+DolphinNewMenuObserver::DolphinNewMenuObserver() :
+    QObject(0)
+{
+}
+
+DolphinNewMenuObserver::~DolphinNewMenuObserver()
+{
+}
+
+#include "dolphinnewmenuobserver.moc"
diff --git a/src/views/dolphinnewmenuobserver.h b/src/views/dolphinnewmenuobserver.h
new file mode 100644
index 000000000..dc9010a43
--- /dev/null
+++ b/src/views/dolphinnewmenuobserver.h
@@ -0,0 +1,56 @@
+/***************************************************************************
+ *   Copyright (C) 2009 by Peter Penz <[email protected]>                  *
+ *                                                                         *
+ *   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            *
+ ***************************************************************************/
+
+#ifndef DOLPHINNEWMENUOBSERVER_H
+#define DOLPHINNEWMENUOBSERVER_H
+
+#include <QObject>
+
+#include "libdolphin_export.h"
+
+class KNewFileMenu;
+class KUrl;
+
+/**
+ * @brief Allows to observe new file items that have been created
+ *        by a DolphinNewMenu instance.
+ *
+ * As soon as a DolphinNewMenu instance created a new item,
+ * the observer will emit the signal itemCreated().
+ */
+class LIBDOLPHINPRIVATE_EXPORT DolphinNewMenuObserver : public QObject
+{
+    Q_OBJECT
+
+public:
+    static DolphinNewMenuObserver& instance();
+    void attach(const KNewFileMenu* menu);
+    void detach(const KNewFileMenu* menu);
+
+signals:
+    void itemCreated(const KUrl& url);
+
+private:
+    DolphinNewMenuObserver();
+    virtual ~DolphinNewMenuObserver();
+
+    friend class DolphinNewMenuObserverSingleton;
+};
+
+#endif
diff --git a/src/views/dolphinremoteencoding.cpp b/src/views/dolphinremoteencoding.cpp
new file mode 100644
index 000000000..397eaccc0
--- /dev/null
+++ b/src/views/dolphinremoteencoding.cpp
@@ -0,0 +1,241 @@
+/***************************************************************************
+ *   Copyright (C) 2009 by Rahman Duran <[email protected]>           *
+ *                                                                         *
+ *   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            *
+ ***************************************************************************/
+ 
+ /*
+ * This code is largely based on the kremoteencodingplugin
+ * Copyright (c) 2003 Thiago Macieira <[email protected]>
+ * Distributed under the same terms.
+ */
+ 
+#include "dolphinremoteencoding.h"
+#include "dolphinviewactionhandler.h"
+
+#include <kdebug.h>
+#include <kactionmenu.h>
+#include <kactioncollection.h>
+#include <kicon.h>
+#include <klocale.h>
+#include <kglobal.h>
+#include <kmimetype.h>
+#include <kconfig.h>
+#include <kcharsets.h>
+#include <kmenu.h>
+#include <kprotocolinfo.h>
+#include <kprotocolmanager.h>
+#include <kio/slaveconfig.h>
+#include <kio/scheduler.h>
+#include <kconfiggroup.h>
+
+#define DATA_KEY        QLatin1String("Charset")
+
+DolphinRemoteEncoding::DolphinRemoteEncoding(QObject* parent, DolphinViewActionHandler* actionHandler)
+   :QObject(parent),
+    m_actionHandler(actionHandler),
+    m_loaded(false),
+    m_idDefault(0)    
+{
+    m_menu = new KActionMenu(KIcon("character-set"), i18n("Select Remote Charset"), this);
+    m_actionHandler->actionCollection()->addAction("change_remote_encoding", m_menu);
+    connect(m_menu->menu(), SIGNAL(aboutToShow()),
+          this, SLOT(slotAboutToShow()));
+
+    m_menu->setEnabled(false);
+    m_menu->setDelayed(false);
+}
+
+DolphinRemoteEncoding::~DolphinRemoteEncoding()
+{
+}
+
+void DolphinRemoteEncoding::slotReload()
+{
+    loadSettings();
+}
+
+void DolphinRemoteEncoding::loadSettings()
+{
+    m_loaded = true;
+    m_encodingDescriptions = KGlobal::charsets()->descriptiveEncodingNames();
+
+    fillMenu();
+}
+
+void DolphinRemoteEncoding::slotAboutToOpenUrl()
+{
+    KUrl oldURL = m_currentURL;
+    m_currentURL = m_actionHandler->currentView()->url();
+
+    if (m_currentURL.protocol() != oldURL.protocol()) {
+        // This plugin works on ftp, fish, etc.
+        // everything whose type is T_FILESYSTEM except for local files
+        if (!m_currentURL.isLocalFile() &&
+            KProtocolManager::outputType(m_currentURL) == KProtocolInfo::T_FILESYSTEM) {
+          
+            m_menu->setEnabled(true);
+            loadSettings();
+        } else {
+            m_menu->setEnabled(false);
+        }
+        return;
+    }
+
+    if (m_currentURL.host() != oldURL.host()) {
+        updateMenu();
+    }
+}
+
+void DolphinRemoteEncoding::fillMenu()
+{
+    KMenu* menu = m_menu->menu();
+    menu->clear();
+
+ 
+    for (int i = 0; i < m_encodingDescriptions.size();i++) {
+        QAction* action = new QAction(m_encodingDescriptions.at(i), this);
+        action->setCheckable(true);
+        action->setData(i);
+        menu->addAction(action);
+    }
+    menu->addSeparator();
+
+    menu->addAction(i18n("Reload"), this, SLOT(slotReload()), 0);
+    menu->addAction(i18n("Default"), this, SLOT(slotDefault()), 0)->setCheckable(true);
+    m_idDefault = m_encodingDescriptions.size() + 2;
+  
+    connect(menu, SIGNAL(triggered(QAction*)), this, SLOT(slotItemSelected(QAction*)));
+}
+
+void DolphinRemoteEncoding::updateMenu()
+{
+    if (!m_loaded) {
+        loadSettings();
+    }
+  
+    // uncheck everything
+    for (int i =  0; i < m_menu->menu()->actions().count(); i++) {
+        m_menu->menu()->actions().at(i)->setChecked(false);
+    }
+  
+    QString charset = KIO::SlaveConfig::self()->configData(m_currentURL.protocol(),
+                                                           m_currentURL.host(), DATA_KEY);
+
+    if (!charset.isEmpty()) {
+        int id = 0;
+        bool isFound = false;
+        for (int i = 0; i < m_encodingDescriptions.size(); i++) {
+            if (m_encodingDescriptions.at(i).contains(charset)) {
+                isFound = true;
+                id = i;
+                break;
+            }
+        }
+      
+        kDebug() << "URL=" << m_currentURL << " charset=" << charset;
+
+        if (!isFound) {
+            kWarning() << "could not find entry for charset=" << charset ;
+        } else {
+            m_menu->menu()->actions().at(id)->setChecked(true);
+        }
+    } else {
+        m_menu->menu()->actions().at(m_idDefault)->setChecked(true);
+    }
+    
+}
+
+void DolphinRemoteEncoding::slotAboutToShow()
+{
+    if (!m_loaded) {
+        loadSettings();
+    }
+    updateMenu();
+}
+
+void DolphinRemoteEncoding::slotItemSelected(QAction* action)
+{
+    if (action != 0) {
+        int id = action->data().toInt();
+    
+        KConfig config(("kio_" + m_currentURL.protocol() + "rc").toLatin1());
+        QString host = m_currentURL.host();
+        if (m_menu->menu()->actions().at(id)->isChecked()) {
+            QString charset = KGlobal::charsets()->encodingForName(m_encodingDescriptions.at(id));
+            KConfigGroup cg(&config, host);
+            cg.writeEntry(DATA_KEY, charset);
+            config.sync();
+
+            // Update the io-slaves...
+            updateView();
+        }
+    }
+}
+
+void DolphinRemoteEncoding::slotDefault()
+{
+    // We have no choice but delete all higher domain level
+    // settings here since it affects what will be matched.
+    KConfig config(("kio_" + m_currentURL.protocol() + "rc").toLatin1());
+
+    QStringList partList = m_currentURL.host().split('.', QString::SkipEmptyParts);
+    if (!partList.isEmpty()) {
+        partList.erase(partList.begin());
+
+        QStringList domains;
+        // Remove the exact name match...
+        domains << m_currentURL.host();
+
+        while (partList.count()) {
+            if (partList.count() == 2) {
+                if (partList[0].length() <= 2 && partList[1].length() == 2) {
+                    break;
+                }
+            }
+
+            if (partList.count() == 1) {
+                break;
+            }
+
+            domains << partList.join(".");
+            partList.erase(partList.begin());
+        }
+
+        for (QStringList::const_iterator it = domains.constBegin(); it != domains.constEnd();++it) {
+            kDebug() << "Domain to remove: " << *it;
+            if (config.hasGroup(*it)) {
+                config.deleteGroup(*it);
+            } else if (config.group("").hasKey(*it)) {
+                config.group("").deleteEntry(*it); //don't know what group name is supposed to be XXX
+            }
+        }
+    }
+    config.sync();
+
+    // Update the io-slaves.
+    updateView();
+}
+
+void DolphinRemoteEncoding::updateView()
+{
+    KIO::Scheduler::emitReparseSlaveConfiguration();
+    // Reload the page with the new charset
+    m_actionHandler->currentView()->setUrl(m_currentURL);
+    m_actionHandler->currentView()->reload();
+}
+
+#include "dolphinremoteencoding.moc"
diff --git a/src/views/dolphinremoteencoding.h b/src/views/dolphinremoteencoding.h
new file mode 100644
index 000000000..54499f78b
--- /dev/null
+++ b/src/views/dolphinremoteencoding.h
@@ -0,0 +1,69 @@
+/***************************************************************************
+ *   Copyright (C) 2009 by Rahman Duran <[email protected]>           *
+ *                                                                         *
+ *   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            *
+ ***************************************************************************/
+
+#ifndef DOLPHINREMOTEENCODING_H
+#define DOLPHINREMOTEENCODING_H
+
+#include <QStringList>
+#include <QtGui/QAction>
+#include <kurl.h>
+#include "libdolphin_export.h"
+
+
+class KActionMenu;
+class DolphinViewActionHandler;
+
+/**
+ * @brief Allows to chnage character encoding for remote urls like ftp.
+ *
+ * When browsing remote url, its possible to change encoding from Tools Menu.
+ */
+
+class LIBDOLPHINPRIVATE_EXPORT DolphinRemoteEncoding: public QObject
+{
+  Q_OBJECT
+public:
+  DolphinRemoteEncoding(QObject* parent, DolphinViewActionHandler* actionHandler);
+  ~DolphinRemoteEncoding();
+
+public Q_SLOTS:
+  void slotAboutToOpenUrl();
+  void slotItemSelected(QAction* action);
+  void slotReload();
+  void slotDefault();
+  
+private Q_SLOTS:
+  void slotAboutToShow();
+  
+private:
+  void updateView();
+  void loadSettings();
+  void fillMenu();
+  void updateMenu();
+
+  KActionMenu* m_menu;
+  QStringList m_encodingDescriptions;
+  KUrl m_currentURL;
+  DolphinViewActionHandler* m_actionHandler;
+
+  bool m_loaded;
+  int m_idDefault;
+};
+
+#endif
diff --git a/src/views/dolphinsortfilterproxymodel.cpp b/src/views/dolphinsortfilterproxymodel.cpp
new file mode 100644
index 000000000..70256f156
--- /dev/null
+++ b/src/views/dolphinsortfilterproxymodel.cpp
@@ -0,0 +1,81 @@
+/***************************************************************************
+ *   Copyright (C) 2006-2010 by Peter Penz <[email protected]>             *
+ *   Copyright (C) 2006 by Dominic Battre <[email protected]>              *
+ *   Copyright (C) 2006 by Martin Pool <[email protected]>                 *
+ *   Copyright (C) 2007 by Rafael Fernández López <[email protected]>      *
+ *                                                                         *
+ *   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 "dolphinsortfilterproxymodel.h"
+
+DolphinSortFilterProxyModel::DolphinSortFilterProxyModel(QObject* parent) :
+    KDirSortFilterProxyModel(parent),
+    m_sorting(DolphinView::SortByName),
+    m_sortOrder(Qt::AscendingOrder)
+{
+}
+
+DolphinSortFilterProxyModel::~DolphinSortFilterProxyModel()
+{
+}
+
+void DolphinSortFilterProxyModel::setSorting(DolphinView::Sorting sorting)
+{
+    m_sorting = sorting;
+    KDirSortFilterProxyModel::sort(static_cast<int>(m_sorting), m_sortOrder);
+}
+
+void DolphinSortFilterProxyModel::setSortOrder(Qt::SortOrder sortOrder)
+{
+    m_sortOrder = sortOrder;
+    KDirSortFilterProxyModel::sort(static_cast<int>(m_sorting), m_sortOrder);
+}
+
+void DolphinSortFilterProxyModel::setSortFoldersFirst(bool foldersFirst)
+{
+    if (foldersFirst != sortFoldersFirst()) {
+        KDirSortFilterProxyModel::setSortFoldersFirst(foldersFirst);
+
+        // We need to make sure that the files and folders are really resorted.
+        // Without the following two lines, QSortFilterProxyModel::sort(int column, Qt::SortOrder order)
+        // would do nothing because neither the column nor the sort order have changed.
+        // TODO: remove this hack if we find a better way to force the ProxyModel to re-sort the data.
+        const Qt::SortOrder tmpSortOrder = (m_sortOrder == Qt::AscendingOrder ? Qt::DescendingOrder : Qt::AscendingOrder);
+        KDirSortFilterProxyModel::sort(static_cast<int>(m_sorting), tmpSortOrder);
+
+        // Now comes the real sorting with the old column and sort order
+        KDirSortFilterProxyModel::sort(static_cast<int>(m_sorting), m_sortOrder);
+    }
+}
+
+void DolphinSortFilterProxyModel::sort(int column, Qt::SortOrder sortOrder)
+{
+    m_sorting = sortingForColumn(column);
+    m_sortOrder = sortOrder;
+
+    emit sortingRoleChanged();
+    KDirSortFilterProxyModel::sort(static_cast<int>(m_sorting), sortOrder);
+}
+
+DolphinView::Sorting DolphinSortFilterProxyModel::sortingForColumn(int column)
+{
+    Q_ASSERT(column >= 0);
+    Q_ASSERT(column <= DolphinView::MaxSortingEnum);
+    return static_cast<DolphinView::Sorting>(column);
+}
+
+#include "dolphinsortfilterproxymodel.moc"
diff --git a/src/views/dolphinsortfilterproxymodel.h b/src/views/dolphinsortfilterproxymodel.h
new file mode 100644
index 000000000..3ae8a059c
--- /dev/null
+++ b/src/views/dolphinsortfilterproxymodel.h
@@ -0,0 +1,85 @@
+/***************************************************************************
+ *   Copyright (C) 2006-2010 by Peter Penz <[email protected]>             *
+ *                                                                         *
+ *   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            *
+ ***************************************************************************/
+
+#ifndef DOLPHINSORTFILTERPROXYMODEL_H
+#define DOLPHINSORTFILTERPROXYMODEL_H
+
+#include <views/dolphinview.h>
+#include <kdirsortfilterproxymodel.h>
+#include <libdolphin_export.h>
+
+/**
+ * @brief Acts as proxy model for DolphinModel to sort and filter
+ *        KFileItems.
+ *
+ * Per default a natural sorting is done. This means that items like:
+ * - item_10.png
+ * - item_1.png
+ * - item_2.png
+ * are sorted like
+ * - item_1.png
+ * - item_2.png
+ * - item_10.png
+ */
+class LIBDOLPHINPRIVATE_EXPORT DolphinSortFilterProxyModel : public KDirSortFilterProxyModel
+{
+    Q_OBJECT
+
+public:
+    DolphinSortFilterProxyModel(QObject* parent = 0);
+    virtual ~DolphinSortFilterProxyModel();
+
+    void setSorting(DolphinView::Sorting sorting);
+    DolphinView::Sorting sorting() const;
+
+    void setSortOrder(Qt::SortOrder sortOrder);
+    Qt::SortOrder sortOrder() const;
+
+    void setSortFoldersFirst(bool foldersFirst);
+
+    /** @reimplemented */
+    virtual void sort(int column,
+                      Qt::SortOrder order = Qt::AscendingOrder);
+
+    /**
+     * Helper method to get the DolphinView::Sorting type for a given
+     * column \a column. If the column is smaller 0 or greater than the
+     * available columns, DolphinView::SortByName is returned.
+     */
+    static DolphinView::Sorting sortingForColumn(int column);
+
+signals:
+    void sortingRoleChanged();
+
+private:
+    DolphinView::Sorting m_sorting:16;
+    Qt::SortOrder m_sortOrder:16;
+};
+
+inline DolphinView::Sorting DolphinSortFilterProxyModel::sorting() const
+{
+    return m_sorting;
+}
+
+inline Qt::SortOrder DolphinSortFilterProxyModel::sortOrder() const
+{
+    return m_sortOrder;
+}
+
+#endif
diff --git a/src/views/dolphinviewactionhandler.cpp b/src/views/dolphinviewactionhandler.cpp
new file mode 100644
index 000000000..d2eaa4d51
--- /dev/null
+++ b/src/views/dolphinviewactionhandler.cpp
@@ -0,0 +1,518 @@
+/***************************************************************************
+ *   Copyright (C) 2008 by David Faure <[email protected]>                     *
+ *                                                                         *
+ *   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 "dolphinviewactionhandler.h"
+
+#include "additionalinfoaccessor.h"
+#include "settings/viewpropertiesdialog.h"
+#include "views/dolphinview.h"
+#include "views/zoomlevelinfo.h"
+#include <konq_operations.h>
+
+#include <kaction.h>
+#include <kactioncollection.h>
+#include <kactionmenu.h>
+#include <kfileitemdelegate.h>
+#include <klocale.h>
+#include <knewmenu.h>
+#include <kselectaction.h>
+#include <ktoggleaction.h>
+#include <krun.h>
+#include <kpropertiesdialog.h>
+
+
+DolphinViewActionHandler::DolphinViewActionHandler(KActionCollection* collection, QObject* parent)
+    : QObject(parent),
+      m_actionCollection(collection),
+      m_currentView(0)
+{
+    Q_ASSERT(m_actionCollection);
+    createActions();
+}
+
+void DolphinViewActionHandler::setCurrentView(DolphinView* view)
+{
+    Q_ASSERT(view);
+
+    if (m_currentView)
+        disconnect(m_currentView, 0, this, 0);
+
+    m_currentView = view;
+
+    connect(view, SIGNAL(modeChanged()),
+            this, SLOT(updateViewActions()));
+    connect(view, SIGNAL(showPreviewChanged()),
+            this, SLOT(slotShowPreviewChanged()));
+    connect(view, SIGNAL(sortOrderChanged(Qt::SortOrder)),
+            this, SLOT(slotSortOrderChanged(Qt::SortOrder)));
+    connect(view, SIGNAL(sortFoldersFirstChanged(bool)),
+            this, SLOT(slotSortFoldersFirstChanged(bool)));
+    connect(view, SIGNAL(additionalInfoChanged()),
+            this, SLOT(slotAdditionalInfoChanged()));
+    connect(view, SIGNAL(categorizedSortingChanged()),
+            this, SLOT(slotCategorizedSortingChanged()));
+    connect(view, SIGNAL(showHiddenFilesChanged()),
+            this, SLOT(slotShowHiddenFilesChanged()));
+    connect(view, SIGNAL(sortingChanged(DolphinView::Sorting)),
+            this, SLOT(slotSortingChanged(DolphinView::Sorting)));
+    connect(view, SIGNAL(zoomLevelChanged(int)),
+            this, SLOT(slotZoomLevelChanged(int)));
+}
+
+DolphinView* DolphinViewActionHandler::currentView()
+{
+    return m_currentView;
+}
+
+void DolphinViewActionHandler::createActions()
+{
+    // This action doesn't appear in the GUI, it's for the shortcut only.
+    // KNewFileMenu takes care of the GUI stuff.
+    KAction* newDirAction = m_actionCollection->addAction("create_dir");
+    newDirAction->setText(i18nc("@action", "Create Folder..."));
+    newDirAction->setShortcut(Qt::Key_F10);
+    newDirAction->setIcon(KIcon("folder-new"));
+    connect(newDirAction, SIGNAL(triggered()), this, SIGNAL(createDirectory()));
+
+    // File menu
+
+    KAction* rename = m_actionCollection->addAction("rename");
+    rename->setText(i18nc("@action:inmenu File", "Rename..."));
+    rename->setShortcut(Qt::Key_F2);
+    rename->setIcon(KIcon("edit-rename"));
+    connect(rename, SIGNAL(triggered()), this, SLOT(slotRename()));
+
+    KAction* moveToTrash = m_actionCollection->addAction("move_to_trash");
+    moveToTrash->setText(i18nc("@action:inmenu File", "Move to Trash"));
+    moveToTrash->setIcon(KIcon("user-trash"));
+    moveToTrash->setShortcut(QKeySequence::Delete);
+    connect(moveToTrash, SIGNAL(triggered(Qt::MouseButtons, Qt::KeyboardModifiers)),
+            this, SLOT(slotTrashActivated(Qt::MouseButtons, Qt::KeyboardModifiers)));
+
+    KAction* deleteAction = m_actionCollection->addAction("delete");
+    deleteAction->setIcon(KIcon("edit-delete"));
+    deleteAction->setText(i18nc("@action:inmenu File", "Delete"));
+    deleteAction->setShortcut(Qt::SHIFT | Qt::Key_Delete);
+    connect(deleteAction, SIGNAL(triggered()), this, SLOT(slotDeleteItems()));
+
+    // This action is useful for being enabled when "move_to_trash" should be
+    // disabled and "delete" is enabled (e.g. non-local files), so that Key_Del
+    // can be used for deleting the file (#76016). It needs to be a separate action
+    // so that the Edit menu isn't affected.
+    KAction* deleteWithTrashShortcut = m_actionCollection->addAction("delete_shortcut");
+    // The descriptive text is just for the shortcuts editor.
+    deleteWithTrashShortcut->setText(i18nc("@action \"Move to Trash\" for non-local files, etc.", "Delete (using shortcut for Trash)"));
+    deleteWithTrashShortcut->setShortcut(QKeySequence::Delete);
+    deleteWithTrashShortcut->setEnabled(false);
+    connect(deleteWithTrashShortcut, SIGNAL(triggered()), this, SLOT(slotDeleteItems()));
+
+    KAction *propertiesAction = m_actionCollection->addAction( "properties" );
+    // Well, it's the File menu in dolphinmainwindow and the Edit menu in dolphinpart... :)
+    propertiesAction->setText( i18nc("@action:inmenu File", "Properties") );
+    propertiesAction->setIcon(KIcon("document-properties"));
+    propertiesAction->setShortcut(Qt::ALT | Qt::Key_Return);
+    connect(propertiesAction, SIGNAL(triggered()), SLOT(slotProperties()));
+
+    // View menu
+    KToggleAction* iconsAction = iconsModeAction();
+    KToggleAction* detailsAction = detailsModeAction();
+    KToggleAction* columnsAction = columnsModeAction();
+
+    KSelectAction* viewModeActions = m_actionCollection->add<KSelectAction>("view_mode");
+    viewModeActions->setText(i18nc("@action:intoolbar", "View Mode"));
+    viewModeActions->addAction(iconsAction);
+    viewModeActions->addAction(detailsAction);
+    viewModeActions->addAction(columnsAction);
+    viewModeActions->setToolBarMode(KSelectAction::MenuMode);
+    connect(viewModeActions, SIGNAL(triggered(QAction*)), this, SLOT(slotViewModeActionTriggered(QAction*)));
+
+    KStandardAction::zoomIn(this,
+                            SLOT(zoomIn()),
+                            m_actionCollection);
+
+    KStandardAction::zoomOut(this,
+                             SLOT(zoomOut()),
+                             m_actionCollection);
+
+    KToggleAction* showPreview = m_actionCollection->add<KToggleAction>("show_preview");
+    showPreview->setText(i18nc("@action:intoolbar", "Preview"));
+    showPreview->setToolTip(i18nc("@info", "Show preview of files and folders"));
+    showPreview->setIcon(KIcon("view-preview"));
+    connect(showPreview, SIGNAL(triggered(bool)), this, SLOT(togglePreview(bool)));
+
+    KToggleAction* sortDescending = m_actionCollection->add<KToggleAction>("descending");
+    sortDescending->setText(i18nc("@action:inmenu Sort", "Descending"));
+    connect(sortDescending, SIGNAL(triggered()), this, SLOT(toggleSortOrder()));
+
+    KToggleAction* sortFoldersFirst = m_actionCollection->add<KToggleAction>("folders_first");
+    sortFoldersFirst->setText(i18nc("@action:inmenu Sort", "Folders First"));
+    connect(sortFoldersFirst, SIGNAL(triggered()), this, SLOT(toggleSortFoldersFirst()));
+
+    // View -> Sort By
+    QActionGroup* sortByActionGroup = createSortByActionGroup();
+    connect(sortByActionGroup, SIGNAL(triggered(QAction*)), this, SLOT(slotSortTriggered(QAction*)));
+
+    KActionMenu* sortByActionMenu = m_actionCollection->add<KActionMenu>("sort");
+    sortByActionMenu->setText(i18nc("@action:inmenu View", "Sort By"));
+    sortByActionMenu->setDelayed(false);
+
+    foreach (QAction* action, sortByActionGroup->actions()) {
+        sortByActionMenu->addAction(action);
+    }
+    sortByActionMenu->addSeparator();
+    sortByActionMenu->addAction(sortDescending);
+    sortByActionMenu->addAction(sortFoldersFirst);
+
+    // View -> Additional Information
+    QActionGroup* additionalInfoGroup = createAdditionalInformationActionGroup();
+    connect(additionalInfoGroup, SIGNAL(triggered(QAction*)), this, SLOT(toggleAdditionalInfo(QAction*)));
+
+    KActionMenu* additionalInfoMenu = m_actionCollection->add<KActionMenu>("additional_info");
+    additionalInfoMenu->setText(i18nc("@action:inmenu View", "Additional Information"));
+    additionalInfoMenu->setDelayed(false);
+    foreach (QAction* action, additionalInfoGroup->actions()) {
+        additionalInfoMenu->addAction(action);
+    }
+
+    KToggleAction* showInGroups = m_actionCollection->add<KToggleAction>("show_in_groups");
+    showInGroups->setText(i18nc("@action:inmenu View", "Show in Groups"));
+    connect(showInGroups, SIGNAL(triggered(bool)), this, SLOT(toggleSortCategorization(bool)));
+
+    KToggleAction* showHiddenFiles = m_actionCollection->add<KToggleAction>("show_hidden_files");
+    showHiddenFiles->setText(i18nc("@action:inmenu View", "Show Hidden Files"));
+    showHiddenFiles->setShortcuts(QList<QKeySequence>() << Qt::ALT + Qt::Key_Period << Qt::Key_F8);
+    connect(showHiddenFiles, SIGNAL(triggered(bool)), this, SLOT(toggleShowHiddenFiles(bool)));
+
+    KAction* adjustViewProps = m_actionCollection->addAction("view_properties");
+    adjustViewProps->setText(i18nc("@action:inmenu View", "Adjust View Properties..."));
+    connect(adjustViewProps, SIGNAL(triggered()), this, SLOT(slotAdjustViewProperties()));
+}
+
+QActionGroup* DolphinViewActionHandler::createAdditionalInformationActionGroup()
+{
+    QActionGroup* additionalInfoGroup = new QActionGroup(m_actionCollection);
+    additionalInfoGroup->setExclusive(false);
+
+    KActionMenu* showInformationMenu = m_actionCollection->add<KActionMenu>("additional_info");
+    showInformationMenu->setText(i18nc("@action:inmenu View", "Additional Information"));
+    showInformationMenu->setDelayed(false);
+
+    const AdditionalInfoAccessor& infoAccessor = AdditionalInfoAccessor::instance();
+
+    const KFileItemDelegate::InformationList infos = infoAccessor.keys();
+    foreach (KFileItemDelegate::Information info, infos) {
+        const QString name = infoAccessor.actionCollectionName(info, AdditionalInfoAccessor::AdditionalInfoType);
+        KToggleAction* action = m_actionCollection->add<KToggleAction>(name);
+        action->setText(infoAccessor.translation(info));
+        action->setData(info);
+        action->setActionGroup(additionalInfoGroup);
+    }
+
+    return additionalInfoGroup;
+}
+
+Q_DECLARE_METATYPE(DolphinView::Sorting)
+
+QActionGroup* DolphinViewActionHandler::createSortByActionGroup()
+{
+    QActionGroup* sortByActionGroup = new QActionGroup(m_actionCollection);
+    sortByActionGroup->setExclusive(true);
+
+    KToggleAction* sortByName = m_actionCollection->add<KToggleAction>("sort_by_name");
+    sortByName->setText(i18nc("@action:inmenu Sort By", "Name"));
+    sortByName->setData(QVariant::fromValue(DolphinView::SortByName));
+    sortByActionGroup->addAction(sortByName);
+
+    const AdditionalInfoAccessor& infoAccessor = AdditionalInfoAccessor::instance();
+    const KFileItemDelegate::InformationList infos = infoAccessor.keys();
+    foreach (KFileItemDelegate::Information info, infos) {
+        const QString name = infoAccessor.actionCollectionName(info, AdditionalInfoAccessor::SortByType);
+        KToggleAction* action = m_actionCollection->add<KToggleAction>(name);
+        action->setText(infoAccessor.translation(info));
+        const DolphinView::Sorting sorting = infoAccessor.sorting(info);
+        action->setData(QVariant::fromValue(sorting));
+        sortByActionGroup->addAction(action);
+    }
+
+    return sortByActionGroup;
+}
+
+void DolphinViewActionHandler::slotViewModeActionTriggered(QAction* action)
+{
+    const DolphinView::Mode mode = action->data().value<DolphinView::Mode>();
+    m_currentView->setMode(mode);
+
+    QAction* viewModeMenu = m_actionCollection->action("view_mode");
+    viewModeMenu->setIcon(KIcon(action->icon()));
+}
+
+void DolphinViewActionHandler::slotRename()
+{
+    emit actionBeingHandled();
+    m_currentView->renameSelectedItems();
+}
+
+void DolphinViewActionHandler::slotTrashActivated(Qt::MouseButtons, Qt::KeyboardModifiers modifiers)
+{
+    emit actionBeingHandled();
+    // Note: kde3's konq_mainwindow.cpp used to check
+    // reason == KAction::PopupMenuActivation && ...
+    // but this isn't supported anymore
+    if (modifiers & Qt::ShiftModifier) {
+        m_currentView->deleteSelectedItems();
+    } else {
+        m_currentView->trashSelectedItems();
+    }
+}
+
+void DolphinViewActionHandler::slotDeleteItems()
+{
+    emit actionBeingHandled();
+    m_currentView->deleteSelectedItems();
+}
+
+void DolphinViewActionHandler::togglePreview(bool show)
+{
+    emit actionBeingHandled();
+    m_currentView->setShowPreview(show);
+}
+
+void DolphinViewActionHandler::slotShowPreviewChanged()
+{
+    // It is not enough to update the 'Show Preview' action, also
+    // the 'Zoom In' and 'Zoom Out' actions must be adapted.
+    updateViewActions();
+}
+
+QString DolphinViewActionHandler::currentViewModeActionName() const
+{
+    switch (m_currentView->mode()) {
+    case DolphinView::IconsView:
+        return "icons";
+    case DolphinView::DetailsView:
+        return "details";
+    case DolphinView::ColumnView:
+        return "columns";
+    }
+    return QString(); // can't happen
+}
+
+KActionCollection* DolphinViewActionHandler::actionCollection()
+{
+    return m_actionCollection;
+}
+
+void DolphinViewActionHandler::updateViewActions()
+{
+    QAction* viewModeAction = m_actionCollection->action(currentViewModeActionName());
+    if (viewModeAction != 0) {
+        viewModeAction->setChecked(true);
+
+        QAction* viewModeMenu = m_actionCollection->action("view_mode");
+        viewModeMenu->setIcon(KIcon(viewModeAction->icon()));
+    }
+
+    QAction* showPreviewAction = m_actionCollection->action("show_preview");
+    showPreviewAction->setChecked(m_currentView->showPreview());
+
+    slotSortOrderChanged(m_currentView->sortOrder());
+    slotSortFoldersFirstChanged(m_currentView->sortFoldersFirst());
+    slotAdditionalInfoChanged();
+    slotCategorizedSortingChanged();
+    slotSortingChanged(m_currentView->sorting());
+    slotZoomLevelChanged(m_currentView->zoomLevel());
+
+    QAction* showHiddenFilesAction = m_actionCollection->action("show_hidden_files");
+    showHiddenFilesAction->setChecked(m_currentView->showHiddenFiles());
+}
+
+void DolphinViewActionHandler::zoomIn()
+{
+    const int level = m_currentView->zoomLevel();
+    m_currentView->setZoomLevel(level + 1);
+    updateViewActions();
+}
+
+void DolphinViewActionHandler::zoomOut()
+{
+    const int level = m_currentView->zoomLevel();
+    m_currentView->setZoomLevel(level - 1);
+    updateViewActions();
+}
+
+void DolphinViewActionHandler::toggleSortOrder()
+{
+    m_currentView->toggleSortOrder();
+}
+
+void DolphinViewActionHandler::toggleSortFoldersFirst()
+{
+    m_currentView->toggleSortFoldersFirst();
+}
+
+void DolphinViewActionHandler::slotSortOrderChanged(Qt::SortOrder order)
+{
+    QAction* descending = m_actionCollection->action("descending");
+    const bool sortDescending = (order == Qt::DescendingOrder);
+    descending->setChecked(sortDescending);
+}
+
+void DolphinViewActionHandler::slotSortFoldersFirstChanged(bool foldersFirst)
+{
+    m_actionCollection->action("folders_first")->setChecked(foldersFirst);
+}
+
+void DolphinViewActionHandler::toggleAdditionalInfo(QAction* action)
+{
+    emit actionBeingHandled();
+    m_currentView->toggleAdditionalInfo(action);
+}
+
+void DolphinViewActionHandler::slotAdditionalInfoChanged()
+{
+    m_currentView->updateAdditionalInfoActions(m_actionCollection);
+}
+
+void DolphinViewActionHandler::toggleSortCategorization(bool categorizedSorting)
+{
+    m_currentView->setCategorizedSorting(categorizedSorting);
+}
+
+void DolphinViewActionHandler::slotCategorizedSortingChanged()
+{
+    QAction* showInGroupsAction = m_actionCollection->action("show_in_groups");
+    showInGroupsAction->setChecked(m_currentView->categorizedSorting());
+    showInGroupsAction->setEnabled(m_currentView->supportsCategorizedSorting());
+}
+
+void DolphinViewActionHandler::toggleShowHiddenFiles(bool show)
+{
+    emit actionBeingHandled();
+    m_currentView->setShowHiddenFiles(show);
+}
+
+void DolphinViewActionHandler::slotShowHiddenFilesChanged()
+{
+    QAction* showHiddenFilesAction = m_actionCollection->action("show_hidden_files");
+    showHiddenFilesAction->setChecked(m_currentView->showHiddenFiles());
+}
+
+
+KToggleAction* DolphinViewActionHandler::iconsModeAction()
+{
+    KToggleAction* iconsView = m_actionCollection->add<KToggleAction>("icons");
+    iconsView->setText(i18nc("@action:inmenu View Mode", "Icons"));
+    iconsView->setToolTip(i18nc("@info", "Icons view mode"));
+    iconsView->setShortcut(Qt::CTRL | Qt::Key_1);
+    iconsView->setIcon(KIcon("view-list-icons"));
+    iconsView->setData(QVariant::fromValue(DolphinView::IconsView));
+    return iconsView;
+}
+
+KToggleAction* DolphinViewActionHandler::detailsModeAction()
+{
+    KToggleAction* detailsView = m_actionCollection->add<KToggleAction>("details");
+    detailsView->setText(i18nc("@action:inmenu View Mode", "Details"));
+    detailsView->setToolTip(i18nc("@info", "Details view mode"));
+    detailsView->setShortcut(Qt::CTRL | Qt::Key_2);
+    detailsView->setIcon(KIcon("view-list-details"));
+    detailsView->setData(QVariant::fromValue(DolphinView::DetailsView));
+    return detailsView;
+}
+
+KToggleAction* DolphinViewActionHandler::columnsModeAction()
+{
+    KToggleAction* columnView = m_actionCollection->add<KToggleAction>("columns");
+    columnView->setText(i18nc("@action:inmenu View Mode", "Columns"));
+    columnView->setToolTip(i18nc("@info", "Columns view mode"));
+    columnView->setShortcut(Qt::CTRL | Qt::Key_3);
+    columnView->setIcon(KIcon("view-file-columns"));
+    columnView->setData(QVariant::fromValue(DolphinView::ColumnView));
+    return columnView;
+}
+
+void DolphinViewActionHandler::slotSortingChanged(DolphinView::Sorting sorting)
+{
+    const AdditionalInfoAccessor& infoAccessor = AdditionalInfoAccessor::instance();
+    const KFileItemDelegate::InformationList infos = infoAccessor.keys();
+
+    QAction* action = 0;
+    if (sorting == DolphinView::SortByName) {
+        action = m_actionCollection->action("sort_by_name");
+    } else {
+        foreach (const KFileItemDelegate::Information info, infos) {
+            if (sorting == infoAccessor.sorting(info)) {
+                const QString name = infoAccessor.actionCollectionName(info, AdditionalInfoAccessor::SortByType);
+                action = m_actionCollection->action(name);
+                break;
+            }
+        }
+    }
+
+    if (action != 0) {
+        action->setChecked(true);
+
+        QAction* sortByMenu =  m_actionCollection->action("sort");
+        sortByMenu->setIcon(KIcon(action->icon()));
+    }
+}
+
+void DolphinViewActionHandler::slotZoomLevelChanged(int level)
+{
+    QAction* zoomInAction = m_actionCollection->action(KStandardAction::name(KStandardAction::ZoomIn));
+    if (zoomInAction != 0) {
+        zoomInAction->setEnabled(level < ZoomLevelInfo::maximumLevel());
+    }
+
+    QAction* zoomOutAction = m_actionCollection->action(KStandardAction::name(KStandardAction::ZoomOut));
+    if (zoomOutAction != 0) {
+        zoomOutAction->setEnabled(level > ZoomLevelInfo::minimumLevel());
+    }
+}
+
+void DolphinViewActionHandler::slotSortTriggered(QAction* action)
+{
+    const DolphinView::Sorting sorting = action->data().value<DolphinView::Sorting>();
+    m_currentView->setSorting(sorting);
+}
+
+void DolphinViewActionHandler::slotAdjustViewProperties()
+{
+    emit actionBeingHandled();
+    QPointer<ViewPropertiesDialog> dialog = new ViewPropertiesDialog(m_currentView);
+    dialog->exec();
+    delete dialog;
+}
+
+void DolphinViewActionHandler::slotProperties()
+{
+    KPropertiesDialog* dialog = 0;
+    const KFileItemList list = m_currentView->selectedItems();
+    if (list.isEmpty()) {
+        const KUrl url = m_currentView->url();
+        dialog = new KPropertiesDialog(url, m_currentView);
+    } else {
+        dialog = new KPropertiesDialog(list, m_currentView);
+    }
+
+    dialog->setAttribute(Qt::WA_DeleteOnClose);
+    dialog->show();
+    dialog->raise();
+    dialog->activateWindow();
+}
diff --git a/src/views/dolphinviewactionhandler.h b/src/views/dolphinviewactionhandler.h
new file mode 100644
index 000000000..05339ce37
--- /dev/null
+++ b/src/views/dolphinviewactionhandler.h
@@ -0,0 +1,252 @@
+/***************************************************************************
+ *   Copyright (C) 2008 by David Faure <[email protected]>                     *
+ *                                                                         *
+ *   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            *
+ ***************************************************************************/
+
+
+#ifndef DOLPHINVIEWACTIONHANDLER_H
+#define DOLPHINVIEWACTIONHANDLER_H
+
+#include "libdolphin_export.h"
+#include <kactionmenu.h>
+#include <kselectaction.h>
+#include "views/dolphinview.h"
+#include <QtCore/QObject>
+
+class KToggleAction;
+class QAction;
+class QActionGroup;
+class DolphinView;
+class KActionCollection;
+
+/**
+ * @short Handles all actions for DolphinView
+ *
+ * The action handler owns all the actions and slots related to DolphinView,
+ * but can the view that is acts upon can be switched to another one
+ * (this is used in the case of split views).
+ *
+ * The purpose of this class is also to share this code between DolphinMainWindow
+ * and DolphinPart.
+ *
+ * @see DolphinView
+ * @see DolphinMainWindow
+ * @see DolphinPart
+ */
+class LIBDOLPHINPRIVATE_EXPORT DolphinViewActionHandler : public QObject
+{
+    Q_OBJECT
+
+public:
+    explicit DolphinViewActionHandler(KActionCollection* collection, QObject* parent);
+
+    /**
+     * Sets the view that this action handler should work on.
+     */
+    void setCurrentView(DolphinView* view);
+
+    /**
+     * Returns the view that this action handler should work on.
+     */
+    DolphinView* currentView();
+
+    /**
+     * Returns the name of the action for the current viewmode
+     */
+    QString currentViewModeActionName() const;
+
+    /**
+     * Returns m_actionCollection
+     */
+    KActionCollection* actionCollection();
+
+public Q_SLOTS:
+    /**
+     * Update all actions in the 'View' menu, i.e. those that depend on the
+     * settings in the current view.
+     */
+    void updateViewActions();
+
+Q_SIGNALS:
+    /**
+     * Emitted by DolphinViewActionHandler when the user triggered an action.
+     * This is only used for clearining the statusbar in DolphinMainWindow.
+     */
+    void actionBeingHandled();
+
+    /**
+     * Emitted if the user requested creating a new directory by the F10 key.
+     * The receiver of the signal (DolphinMainWindow or DolphinPart) invokes
+     * the method createDirectory of their KNewFileMenu instance.
+     */
+    void createDirectory();
+
+private Q_SLOTS:
+    /**
+     * Emitted when the user requested a change of view mode
+     */
+    void slotViewModeActionTriggered(QAction*);
+
+    /**
+     * Let the user input a name for the selected item(s) and trigger
+     * a renaming afterwards.
+     */
+    void slotRename();
+
+    /**
+     * Moves the selected items of the active view to the trash.
+     * This methods adds "shift means del" handling.
+     */
+    void slotTrashActivated(Qt::MouseButtons, Qt::KeyboardModifiers);
+
+    /**
+     * Deletes the selected items of the active view.
+     */
+    void slotDeleteItems();
+
+    /**
+     * Switches between showing a preview of the file content and showing the icon.
+     */
+    void togglePreview(bool);
+
+    /** Updates the state of the 'Show preview' menu action. */
+    void slotShowPreviewChanged();
+
+    /** Increases the size of the current set view mode. */
+    void zoomIn();
+
+    /** Decreases the size of the current set view mode. */
+    void zoomOut();
+
+    /** Switches between an ascending and descending sorting order. */
+    void toggleSortOrder();
+
+    /** Switches between a separate sorting and a mixed sorting of files and folders. */
+    void toggleSortFoldersFirst();
+
+    /**
+     * Updates the state of the 'Sort Ascending/Descending' action.
+     */
+    void slotSortOrderChanged(Qt::SortOrder order);
+
+    /**
+     * Updates the state of the 'Sort Folders First' action.
+     */
+    void slotSortFoldersFirstChanged(bool foldersFirst);
+
+    /**
+     * Updates the state of the 'Sort by' actions.
+     */
+    void slotSortingChanged(DolphinView::Sorting sorting);
+
+    /**
+     * Updates the state of the 'Zoom In' and 'Zoom Out' actions.
+     */
+    void slotZoomLevelChanged(int level);
+
+    /**
+     * Switches on or off the displaying of additional information
+     * as specified by \a action.
+     */
+    void toggleAdditionalInfo(QAction* action);
+
+    /**
+     * Changes the sorting of the current view.
+     */
+    void slotSortTriggered(QAction*);
+
+    /**
+     * Updates the state of the 'Additional Information' actions.
+     */
+    void slotAdditionalInfoChanged();
+
+    /**
+     * Switches between sorting by categories or not.
+     */
+    void toggleSortCategorization(bool);
+
+    /**
+     * Updates the state of the 'Categorized sorting' menu action.
+     */
+    void slotCategorizedSortingChanged();
+
+    /**
+     * Switches between showing and hiding of hidden marked files
+     */
+    void toggleShowHiddenFiles(bool);
+
+    /**
+     * Updates the state of the 'Show hidden files' menu action.
+     */
+    void slotShowHiddenFilesChanged();
+
+    /**
+     * Opens the view properties dialog, which allows to modify the properties
+     * of the currently active view.
+     */
+    void slotAdjustViewProperties();
+
+    /**
+     * Connected to the "properties" action.
+     * Opens the properties dialog for the selected items of the
+     * active view. The properties dialog shows information
+     * like name, size and permissions.
+     */
+    void slotProperties();
+
+private:
+    /**
+     * Create all the actions.
+     * This is called only once (by the constructor)
+     */
+    void createActions();
+
+    /**
+     * Creates an action group with all the "show additional information" actions in it.
+     * Helper method for createActions();
+     */
+    QActionGroup* createAdditionalInformationActionGroup();
+
+    /**
+     * Creates an action group with all the "sort by" actions in it.
+     * Helper method for createActions();
+     */
+    QActionGroup* createSortByActionGroup();
+
+    /**
+     * Returns the "switch to icons mode" action.
+     * Helper method for createActions();
+     */
+    KToggleAction* iconsModeAction();
+
+    /**
+     * Returns the "switch to details mode" action.
+     * Helper method for createActions();
+     */
+    KToggleAction* detailsModeAction();
+
+    /**
+     * Returns the "switch to columns mode" action.
+     * Helper method for createActions();
+     */
+    KToggleAction* columnsModeAction();
+
+    KActionCollection* m_actionCollection;
+    DolphinView* m_currentView;
+};
+
+#endif /* DOLPHINVIEWACTIONHANDLER_H */
diff --git a/src/views/draganddrophelper.cpp b/src/views/draganddrophelper.cpp
new file mode 100644
index 000000000..0cca59ac4
--- /dev/null
+++ b/src/views/draganddrophelper.cpp
@@ -0,0 +1,189 @@
+/***************************************************************************
+ *   Copyright (C) 2007 by Peter Penz <[email protected]>                  *
+ *   Copyright (C) 2007 by David Faure <[email protected]>                     *
+ *                                                                         *
+ *   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 "draganddrophelper.h"
+
+#include <kdirmodel.h>
+#include <kfileitem.h>
+#include <kicon.h>
+#include <klocale.h>
+#include <konq_operations.h>
+
+#include "views/dolphiniconsview.h"
+#include "views/dolphinviewcontroller.h"
+
+#include <QAbstractItemView>
+#include <QAbstractProxyModel>
+#include <QtDBus>
+#include <QDrag>
+#include <QPainter>
+
+class DragAndDropHelperSingleton
+{
+public:
+    DragAndDropHelper instance;
+};
+K_GLOBAL_STATIC(DragAndDropHelperSingleton, s_dragAndDropHelper)
+
+DragAndDropHelper& DragAndDropHelper::instance()
+{
+    return s_dragAndDropHelper->instance;
+}
+
+bool DragAndDropHelper::isMimeDataSupported(const QMimeData* mimeData) const
+{
+    return mimeData->hasUrls() || mimeData->hasFormat("application/x-kde-dndextract");
+}
+
+void DragAndDropHelper::startDrag(QAbstractItemView* itemView,
+                                  Qt::DropActions supportedActions,
+                                  DolphinViewController* dolphinViewController)
+{
+    // Do not start a new drag until the previous one has been finished.
+    // This is a (possibly temporary) fix for bug #187884.
+    static bool isDragging = false;
+    if (isDragging) {
+        return;
+    }
+    isDragging = true;
+
+    const QModelIndexList indexes = itemView->selectionModel()->selectedIndexes();
+    if (!indexes.isEmpty()) {
+        QMimeData *data = itemView->model()->mimeData(indexes);
+        if (data == 0) {
+            return;
+        }
+
+        if (dolphinViewController != 0) {
+            dolphinViewController->requestToolTipHiding();
+        }
+
+        QDrag* drag = new QDrag(itemView);
+        drag->setPixmap(createDragPixmap(itemView));
+        drag->setMimeData(data);
+
+        m_dragSource = itemView;
+        drag->exec(supportedActions, Qt::IgnoreAction);
+        m_dragSource = 0;
+    }
+    isDragging = false;
+}
+
+bool DragAndDropHelper::isDragSource(QAbstractItemView* itemView) const
+{
+    return (m_dragSource != 0) && (m_dragSource == itemView);
+}
+
+void DragAndDropHelper::dropUrls(const KFileItem& destItem,
+                                 const KUrl& destPath,
+                                 QDropEvent* event,
+                                 QWidget* widget)
+{
+    const bool dropToItem = !destItem.isNull() && (destItem.isDir() || destItem.isDesktopFile());
+    const KUrl destination = dropToItem ? destItem.url() : destPath;
+
+    const QMimeData* mimeData = event->mimeData();
+    if (mimeData->hasFormat("application/x-kde-dndextract")) {
+        QString remoteDBusClient = mimeData->data("application/x-kde-dndextract");
+        QDBusMessage message = QDBusMessage::createMethodCall(remoteDBusClient, "/DndExtract",
+                                                              "org.kde.DndExtract", "extractSelectedFilesTo");
+        message.setArguments(QVariantList() << destination.path());
+        QDBusConnection::sessionBus().call(message);
+    } else {
+        const KUrl::List urls = KUrl::List::fromMimeData(event->mimeData());
+        const int urlsCount = urls.count();
+        if (urlsCount == 0) {
+            // TODO: handle dropping of other data
+        } else if ((urlsCount == 1) && (urls.first() == destination)) {
+            emit errorMessage(i18nc("@info:status", "A folder cannot be dropped into itself"));
+        } else if (dropToItem) {
+            KonqOperations::doDrop(destItem, destination, event, widget);
+        } else {
+            KonqOperations::doDrop(KFileItem(), destination, event, widget);
+        }
+    }
+}
+
+DragAndDropHelper::DragAndDropHelper()
+    : m_dragSource(0)
+{
+}
+
+QPixmap DragAndDropHelper::createDragPixmap(QAbstractItemView* itemView) const
+{
+    const QModelIndexList selectedIndexes = itemView->selectionModel()->selectedIndexes();    
+    Q_ASSERT(!selectedIndexes.isEmpty());
+    
+    QAbstractProxyModel* proxyModel = static_cast<QAbstractProxyModel*>(itemView->model());
+    KDirModel* dirModel = static_cast<KDirModel*>(proxyModel->sourceModel());
+    
+    const int itemCount = selectedIndexes.count();
+    
+    // If more than one item is dragged, align the items inside a
+    // rectangular grid. The maximum grid size is limited to 5 x 5 items.
+    int xCount = 3;
+    int size = KIconLoader::SizeMedium;
+    if (itemCount > 16) {
+        xCount = 5;
+        size = KIconLoader::SizeSmall;
+    } else if (itemCount > 9) {
+        xCount = 4;
+        size = KIconLoader::SizeSmallMedium;
+    }
+    
+    if (itemCount < xCount) {
+        xCount = itemCount;
+    }
+    
+    int yCount = itemCount / xCount;
+    if (itemCount % xCount != 0) {
+        ++yCount;
+    }
+    if (yCount > xCount) {
+        yCount = xCount;
+    }
+
+    // Draw the selected items into the grid cells    
+    QPixmap dragPixmap(xCount * size + xCount - 1, yCount * size + yCount - 1);
+    dragPixmap.fill(Qt::transparent);
+    
+    QPainter painter(&dragPixmap);
+    int x = 0;
+    int y = 0;
+    foreach (const QModelIndex& selectedIndex, selectedIndexes) {
+        const QModelIndex index = proxyModel->mapToSource(selectedIndex);
+        const KFileItem item = dirModel->itemForIndex(index);
+        const QPixmap pixmap = item.pixmap(size, size);
+        painter.drawPixmap(x, y, pixmap);
+        
+        x += size + 1;
+        if (x >= dragPixmap.width()) {
+            x = 0;
+            y += size + 1;
+        }
+        if (y >= dragPixmap.height()) {
+            break;
+        }
+    }
+    
+    return dragPixmap;
+}
+
+#include "draganddrophelper.moc"
diff --git a/src/views/draganddrophelper.h b/src/views/draganddrophelper.h
new file mode 100644
index 000000000..3cb506c43
--- /dev/null
+++ b/src/views/draganddrophelper.h
@@ -0,0 +1,102 @@
+/***************************************************************************
+ *   Copyright (C) 2007 by Peter Penz <[email protected]>                  *
+ *   Copyright (C) 2007 by David Faure <[email protected]>                     *
+ *                                                                         *
+ *   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            *
+ ***************************************************************************/
+
+#ifndef DRAGANDDROPHELPER_H
+#define DRAGANDDROPHELPER_H
+
+#include "libdolphin_export.h"
+#include <QObject>
+#include <QPixmap>
+
+class DolphinViewController;
+class KFileItem;
+class KUrl;
+class QDropEvent;
+class QAbstractItemView;
+class QMimeData;
+class QWidget;
+
+/**
+ * @brief Helper class for having a common drag and drop behavior.
+ *
+ * The class is used by DolphinIconsView, DolphinDetailsView,
+ * DolphinColumnView and PanelTreeView to have a consistent
+ * drag and drop behavior between all views.
+ */
+class LIBDOLPHINPRIVATE_EXPORT DragAndDropHelper : public QObject
+{
+    Q_OBJECT
+
+public:
+    static DragAndDropHelper& instance();
+
+    /**
+     * Returns true, if Dolphin supports the dragging of
+     * the given mime data.
+     */
+    bool isMimeDataSupported(const QMimeData* mimeData) const;
+
+    /**
+     * Creates a drag object for the view \a itemView for all selected items.
+     */
+    void startDrag(QAbstractItemView* itemView,
+                   Qt::DropActions supportedActions,
+                   DolphinViewController* dolphinViewController = 0);
+
+    /**
+     * Returns true if and only if the view \a itemView was the last view to 
+     * be passed to startDrag(...), and that drag is still in progress.
+     */
+    bool isDragSource(QAbstractItemView* itemView) const;
+
+    /**
+     * Handles the dropping of URLs to the given
+     * destination. A context menu with the options
+     * 'Move Here', 'Copy Here', 'Link Here' and
+     * 'Cancel' is offered to the user.
+     * @param destItem  Item of the destination (can be null, see KFileItem::isNull()).
+     * @param destPath  Path of the destination.
+     * @param event     Drop event.
+     * @param widget    Source widget where the dragging has been started.
+     */
+    void dropUrls(const KFileItem& destItem,
+                  const KUrl& destPath,
+                  QDropEvent* event,
+                  QWidget* widget);
+signals:
+    void errorMessage(const QString& msg);
+
+private:
+    DragAndDropHelper();
+    
+    /**
+     * Creates a pixmap the contains the all icons of the items
+     * that are dragged.
+     */
+    QPixmap createDragPixmap(QAbstractItemView* itemView) const;
+    
+    // The last view passed in startDrag(...), or 0 if
+    // no startDrag(...) initiated drag is in progress.
+    QAbstractItemView *m_dragSource;
+
+    friend class DragAndDropHelperSingleton;
+};
+
+#endif
diff --git a/src/views/folderexpander.cpp b/src/views/folderexpander.cpp
new file mode 100644
index 000000000..a2dfb137b
--- /dev/null
+++ b/src/views/folderexpander.cpp
@@ -0,0 +1,141 @@
+/***************************************************************************
+ *   Copyright (C) 2008 by Simon St James <[email protected]>  *
+ *                                                                         *
+ *   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 "folderexpander.h"
+
+#include <QtCore/QTimer>
+#include <QtGui/QAbstractItemView>
+#include <QtGui/QTreeView>
+#include <QtGui/QScrollBar>
+
+#include <QtCore/QEvent>
+#include <QtGui/QDragMoveEvent>
+
+#include <QtGui/QSortFilterProxyModel>
+
+#include <kdirmodel.h>
+
+FolderExpander::FolderExpander(QAbstractItemView *view, QSortFilterProxyModel *proxyModel) :
+    QObject(view),
+    m_enabled(true),
+    m_view(view),
+    m_proxyModel(proxyModel),
+    m_autoExpandTriggerTimer(0),
+    m_autoExpandPos()
+{
+    if (m_view == 0)  {
+        return;
+    }
+    if (m_proxyModel == 0)  {
+        return;
+    }
+    KDirModel *m_dirModel = qobject_cast<KDirModel*>(m_proxyModel->sourceModel());
+    if (m_dirModel == 0) {
+        return;
+    }
+
+    // Initialise auto-expand timer.
+    m_autoExpandTriggerTimer = new QTimer(this);
+    m_autoExpandTriggerTimer->setSingleShot(true);
+    connect(m_autoExpandTriggerTimer, SIGNAL(timeout()),
+            this, SLOT(autoExpandTimeout()));
+
+    // The view scrolling complicates matters, so we want to
+    // be informed if they occur.
+    connect(m_view->horizontalScrollBar(), SIGNAL(valueChanged(int)),
+            this, SLOT(viewScrolled()));
+    connect(m_view->verticalScrollBar(), SIGNAL(valueChanged(int)),
+            this, SLOT(viewScrolled()));
+
+    // "Dragging" events are sent to the QAbstractItemView's viewport.
+    m_view->viewport()->installEventFilter(this);
+}
+
+void FolderExpander::setEnabled(bool enabled)
+{
+    m_enabled = enabled;
+}
+
+bool FolderExpander::enabled() const
+{
+    return m_enabled;
+}
+
+FolderExpander::~FolderExpander()
+{
+}
+
+void FolderExpander::viewScrolled()
+{
+    if (m_autoExpandTriggerTimer->isActive())  {
+        m_autoExpandTriggerTimer->start(AUTO_EXPAND_DELAY);
+    }
+}
+
+void FolderExpander::autoExpandTimeout()
+{
+    if (!m_enabled) {
+        return;
+    }
+
+    // We want to find whether the file currently being hovered over is a
+    // directory. TODO - is there a simpler way, preferably without
+    // needing to pass in m_proxyModel that has a KDirModel as its sourceModel() ... ?
+    QModelIndex proxyIndexToExpand = m_view->indexAt(m_autoExpandPos);
+    QModelIndex indexToExpand = m_proxyModel->mapToSource(proxyIndexToExpand);
+    KDirModel* m_dirModel = qobject_cast< KDirModel* >(m_proxyModel->sourceModel());
+    Q_ASSERT(m_dirModel != 0);
+    KFileItem itemToExpand = m_dirModel->itemForIndex(indexToExpand);
+
+    if (itemToExpand.isNull() || itemToExpand == m_dirModel->itemForIndex(QModelIndex())) {
+        // The second clause occurs when we are expanding the folder represented
+        // by the view, which is a case we should ignore (#182618).
+        return;
+    }
+
+    if (itemToExpand.isDir()) {
+        QTreeView* treeView = qobject_cast<QTreeView*>(m_view);
+        if ((treeView != 0) && treeView->itemsExpandable()) {
+            // Toggle expanded state of this directory.
+            treeView->setExpanded(proxyIndexToExpand, !treeView->isExpanded(proxyIndexToExpand));
+        }
+        else {
+            emit enterDir(proxyIndexToExpand);
+        }
+    }
+}
+
+bool FolderExpander::eventFilter(QObject* watched, QEvent* event)
+{
+    Q_UNUSED(watched);
+    // We're interested in reading Drag* events, but not filtering them,
+    // so always return false.
+    // We just store the position of the hover, here; actually working out
+    // what the hovered item is and whether it is expandable is done in
+    // autoExpandTimeout.
+    if (event->type() == QEvent::DragMove) {
+        QDragMoveEvent *dragMoveEvent = static_cast<QDragMoveEvent*>(event);
+        // (Re-)set the timer while we're still moving and dragging.
+        m_autoExpandTriggerTimer->start(AUTO_EXPAND_DELAY);
+        m_autoExpandPos = dragMoveEvent->pos();
+    } else if (event->type() == QEvent::DragLeave || event->type() == QEvent::Drop) {
+        m_autoExpandTriggerTimer->stop();
+    }
+    return false;
+}
diff --git a/src/views/folderexpander.h b/src/views/folderexpander.h
new file mode 100644
index 000000000..63de57f4a
--- /dev/null
+++ b/src/views/folderexpander.h
@@ -0,0 +1,89 @@
+/***************************************************************************
+ *   Copyright (C) 2008 by Simon St James <[email protected]>  *
+ *                                                                         *
+ *   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            *
+ ***************************************************************************/
+
+#ifndef FOLDEREXPANDER_H
+#define FOLDEREXPANDER_H
+
+// Needs to be exported as FoldersPanel uses it.
+#include "libdolphin_export.h"
+
+#include <QObject>
+#include <QPoint>
+
+class QAbstractItemView;
+class QTreeView;
+class QTimer;
+class QSortFilterProxyModel;
+class QModelIndex;
+
+/**
+ * Grants auto expanding functionality to the provided item view.
+ * Qt has its own auto expand mechanism, but this works only
+ * for QTreeView. Auto expanding of folders is turned on
+ * per default.
+ *
+ * If the provided view is an instance of the class QTreeView, the
+ * expansion of the directory is automatically done on hover. Otherwise
+ * the enterDir() signal is emitted and the caller needs to ensure that
+ * the requested directory is entered.
+ *
+ * The FolderExpander becomes a child of the provided view.
+ */
+class LIBDOLPHINPRIVATE_EXPORT FolderExpander : public QObject
+{
+    Q_OBJECT
+
+public:
+    FolderExpander(QAbstractItemView* view, QSortFilterProxyModel* proxyModel);
+    virtual ~FolderExpander();
+
+    void setEnabled(bool enabled);
+    bool enabled() const;
+
+signals:
+    /**
+     * Is emitted if the directory \a dirModelIndex should be entered. The
+     * signal is not emitted when a QTreeView is used, as the entering of
+     * the directory is already provided by expanding the tree node.
+     */
+    void enterDir(const QModelIndex& dirModelIndex);
+
+
+private slots:
+    void viewScrolled();
+    void autoExpandTimeout();
+
+private:
+    bool m_enabled;
+
+    QAbstractItemView* m_view;
+    QSortFilterProxyModel* m_proxyModel;
+
+    QTimer* m_autoExpandTriggerTimer;
+    QPoint m_autoExpandPos;
+
+    static const int AUTO_EXPAND_DELAY = 700;
+
+    /**
+     * Watchs the drag/move events for the view to decide
+     * whether auto expanding of a folder should be triggered.
+     */
+    bool eventFilter(QObject* watched, QEvent* event);
+};
+#endif
diff --git a/src/views/renamedialog.cpp b/src/views/renamedialog.cpp
new file mode 100644
index 000000000..39e61c464
--- /dev/null
+++ b/src/views/renamedialog.cpp
@@ -0,0 +1,132 @@
+/***************************************************************************
+ *   Copyright (C) 2006 by Peter Penz ([email protected])                  *
+ *                                                                         *
+ *   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 "renamedialog.h"
+
+#include <kfileitem.h>
+#include <klineedit.h>
+#include <klocale.h>
+
+#include <QtGui/QLabel>
+#include <QtGui/QBoxLayout>
+
+RenameDialog::RenameDialog(QWidget *parent, const KFileItemList& items) :
+    KDialog(parent),
+    m_renameOneItem(false)
+{
+    const QSize minSize = minimumSize();
+    setMinimumSize(QSize(320, minSize.height()));
+
+    const int itemCount = items.count();
+    Q_ASSERT(itemCount >= 1);
+    m_renameOneItem = (itemCount == 1);
+
+    setCaption(m_renameOneItem ?
+               i18nc("@title:window", "Rename Item") :
+               i18nc("@title:window", "Rename Items"));
+    setButtons(Ok | Cancel);
+    setDefaultButton(Ok);
+
+    setButtonGuiItem(Ok, KGuiItem(i18nc("@action:button", "&Rename"), "dialog-ok-apply"));
+
+    QWidget* page = new QWidget(this);
+    setMainWidget(page);
+
+    QVBoxLayout* topLayout = new QVBoxLayout(page);
+
+    QLabel* editLabel = 0;
+    if (m_renameOneItem) {
+        m_newName = items.first().name();
+        editLabel = new QLabel(i18nc("@label:textbox", "Rename the item <filename>%1</filename> to:", m_newName),
+                               page);
+    } else {
+        m_newName = i18nc("@info:status", "New name #");
+        editLabel = new QLabel(i18ncp("@label:textbox",
+                                      "Rename the %1 selected item to:",
+                                      "Rename the %1 selected items to:", itemCount),
+                               page);
+    }
+
+    m_lineEdit = new KLineEdit(page);
+
+    QString fileName = items[0].url().prettyUrl();
+    QString extension = KMimeType::extractKnownExtension(fileName.toLower());
+    if (!extension.isEmpty()) {
+        extension.insert(0, '.');
+        // The first item seems to have a extension (e. g. '.jpg' or '.txt'). Now
+        // check whether all other URLs have the same extension. If this is the
+        // case, add this extension to the name suggestion.
+        for (int i = 1; i < itemCount; ++i) {
+            fileName = items[i].url().prettyUrl().toLower();
+            if (!fileName.endsWith(extension)) {
+                // at least one item does not have the same extension
+                extension.truncate(0);
+                break;
+            }
+        }
+    }
+
+    int selectionLength = m_newName.length();
+    if (!m_renameOneItem) {
+        --selectionLength; // don't select the # character
+    }
+
+    const int extensionLength = extension.length();
+    if (extensionLength > 0) {
+        if (m_renameOneItem) {
+            selectionLength -= extensionLength;
+        } else {
+            m_newName.append(extension);
+        }
+    }
+
+    m_lineEdit->setText(m_newName);
+    m_lineEdit->setSelection(0, selectionLength);
+    m_lineEdit->setFocus();
+
+    topLayout->addWidget(editLabel);
+    topLayout->addWidget(m_lineEdit);
+
+    if (!m_renameOneItem) {
+        QLabel* infoLabel = new QLabel(i18nc("@info", "(# will be replaced by ascending numbers)"), page);
+        topLayout->addWidget(infoLabel);
+    }
+}
+
+RenameDialog::~RenameDialog()
+{
+}
+
+void RenameDialog::slotButtonClicked(int button)
+{
+    if (button == Ok) {
+        m_newName = m_lineEdit->text();
+        if (m_newName.isEmpty()) {
+            m_errorString = i18nc("@info:status",
+                                  "The new name is empty. A name with at least one character must be entered.");
+        } else if (!m_renameOneItem && (m_newName.count('#') == 0)) {
+            m_newName.truncate(0);
+            m_errorString = i18nc("@info:status", "The name must contain at least one # character.");
+        }
+    }
+
+    KDialog::slotButtonClicked(button);
+}
+
+#include "renamedialog.moc"
diff --git a/src/views/renamedialog.h b/src/views/renamedialog.h
new file mode 100644
index 000000000..eca5f4d06
--- /dev/null
+++ b/src/views/renamedialog.h
@@ -0,0 +1,98 @@
+/***************************************************************************
+ *   Copyright (C) 2006 by Peter Penz ([email protected])                  *
+ *                                                                         *
+ *   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          *
+ ***************************************************************************/
+#ifndef RENAMEDIALOG_H
+#define RENAMEDIALOG_H
+
+#include "libdolphin_export.h"
+
+#include <kdialog.h>
+#include <kurl.h>
+
+class KFileItem;
+class KFileItemList;
+class KLineEdit;
+
+#include <QString>
+
+/**
+ * @brief Dialog for renaming a variable number of files.
+ *
+ * The renaming is not done by the dialog, the invoker
+ * must do this itself:
+ * \code
+ * RenameDialog dialog(...);
+ * if (dialog.exec() == QDialog::Accepted) {
+ *     const QString& newName = dialog.newName();
+ *     if (newName.isEmpty()) {
+ *         // an invalid name has been chosen, use
+ *         // dialog.errorString() to tell the user about this
+ *     }
+ *     else {
+ *         // rename items corresponding to the new name
+ *     }
+ * }
+ * \endcode
+ */
+class LIBDOLPHINPRIVATE_EXPORT RenameDialog : public KDialog
+{
+    Q_OBJECT
+
+public:
+    explicit RenameDialog(QWidget *parent, const KFileItemList& items);
+    virtual ~RenameDialog();
+
+    /**
+     * Returns the new name of the items. If more than one
+     * item should be renamed, then it is assured that the # character
+     * is part of the returned string. If the returned string is empty,
+     * then RenameDialog::errorString() should be used to show the reason
+     * of having an empty string (e. g. if the # character has
+     * been deleted by the user, although more than one item should be
+     * renamed).
+     */
+    QString newName() const;
+
+    /**
+     * Returns the error string, if Dialog::newName() returned an empty string.
+     */
+    QString errorString() const;
+
+protected slots:
+    virtual void slotButtonClicked(int button);
+
+private:
+    bool m_renameOneItem;
+    KLineEdit* m_lineEdit;
+    QString m_newName;
+    QString m_errorString;
+
+    friend class RenameDialogTest; // allow access for unit testing
+};
+
+inline QString RenameDialog::newName() const
+{
+    return m_newName;
+}
+
+inline QString RenameDialog::errorString() const
+{
+    return m_errorString;
+}
+
+#endif
diff --git a/src/views/viewproperties.cpp b/src/views/viewproperties.cpp
new file mode 100644
index 000000000..3e08358f7
--- /dev/null
+++ b/src/views/viewproperties.cpp
@@ -0,0 +1,310 @@
+/***************************************************************************
+ *   Copyright (C) 2006-2010 by Peter Penz <[email protected]>             *
+ *   Copyright (C) 2006 by Aaron J. Seigo <[email protected]>                 *
+ *                                                                         *
+ *   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 "viewproperties.h"
+
+#include "additionalinfoaccessor.h"
+#include "dolphin_directoryviewpropertysettings.h"
+#include "dolphin_generalsettings.h"
+
+#include <kcomponentdata.h>
+#include <klocale.h>
+#include <kstandarddirs.h>
+#include <kurl.h>
+
+#include <QDate>
+#include <QFile>
+#include <QFileInfo>
+
+#include "settings/dolphinsettings.h"
+
+ViewProperties::ViewProperties(const KUrl& url) :
+    m_changedProps(false),
+    m_autoSave(true),
+    m_node(0)
+{
+    // We try and save it to the file .directory in the directory being viewed.
+    // If the directory is not writable by the user or the directory is not local,
+    // we store the properties information in a local file.
+    GeneralSettings* settings = DolphinSettings::instance().generalSettings();
+    const bool useGlobalViewProps = settings->globalViewProps();
+    if (useGlobalViewProps) {
+        m_filePath = destinationDir("global");
+    } else if (url.isLocalFile()) {
+        m_filePath = url.toLocalFile();
+        const QFileInfo info(m_filePath);
+        if (!info.isWritable()) {
+            m_filePath = destinationDir("local") + m_filePath;
+        }
+    } else {
+        m_filePath = destinationDir("remote") + m_filePath;
+    }
+
+    const QString file = m_filePath + QDir::separator() + QLatin1String(".directory");
+    m_node = new ViewPropertySettings(KSharedConfig::openConfig(file));
+
+    const bool useDefaultProps = !useGlobalViewProps &&
+                                 (!QFileInfo(file).exists() ||
+                                  (m_node->timestamp() < settings->viewPropsTimestamp()));
+    if (useDefaultProps) {
+        // If the .directory file does not exist or the timestamp is too old,
+        // use the values from the global .directory file instead, which acts
+        // as default view for new folders in this case.
+        settings->setGlobalViewProps(true);
+
+        ViewProperties defaultProps(url);
+        setDirProperties(defaultProps);
+
+        settings->setGlobalViewProps(false);
+        m_changedProps = false;
+    }
+}
+
+ViewProperties::~ViewProperties()
+{
+    if (m_changedProps && m_autoSave) {
+        save();
+    }
+
+    delete m_node;
+    m_node = 0;
+}
+
+void ViewProperties::setViewMode(DolphinView::Mode mode)
+{
+    if (m_node->viewMode() != mode) {
+        m_node->setViewMode(mode);
+        updateTimeStamp();
+    }
+}
+
+DolphinView::Mode ViewProperties::viewMode() const
+{
+    return static_cast<DolphinView::Mode>(m_node->viewMode());
+}
+
+void ViewProperties::setShowPreview(bool show)
+{
+    if (m_node->showPreview() != show) {
+        m_node->setShowPreview(show);
+        updateTimeStamp();
+    }
+}
+
+bool ViewProperties::showPreview() const
+{
+    return m_node->showPreview();
+}
+
+void ViewProperties::setShowHiddenFiles(bool show)
+{
+    if (m_node->showHiddenFiles() != show) {
+        m_node->setShowHiddenFiles(show);
+        updateTimeStamp();
+    }
+}
+
+void ViewProperties::setCategorizedSorting(bool categorized)
+{
+    if (m_node->categorizedSorting() != categorized) {
+        m_node->setCategorizedSorting(categorized);
+        updateTimeStamp();
+    }
+}
+
+bool ViewProperties::categorizedSorting() const
+{
+    return m_node->categorizedSorting();
+}
+
+bool ViewProperties::showHiddenFiles() const
+{
+    return m_node->showHiddenFiles();
+}
+
+void ViewProperties::setSorting(DolphinView::Sorting sorting)
+{
+    if (m_node->sorting() != sorting) {
+        m_node->setSorting(sorting);
+        updateTimeStamp();
+    }
+}
+
+DolphinView::Sorting ViewProperties::sorting() const
+{
+    return static_cast<DolphinView::Sorting>(m_node->sorting());
+}
+
+void ViewProperties::setSortOrder(Qt::SortOrder sortOrder)
+{
+    if (m_node->sortOrder() != sortOrder) {
+        m_node->setSortOrder(sortOrder);
+        updateTimeStamp();
+    }
+}
+
+Qt::SortOrder ViewProperties::sortOrder() const
+{
+    return static_cast<Qt::SortOrder>(m_node->sortOrder());
+}
+
+void ViewProperties::setSortFoldersFirst(bool foldersFirst)
+{
+    if (m_node->sortFoldersFirst() != foldersFirst) {
+        m_node->setSortFoldersFirst(foldersFirst);
+        updateTimeStamp();
+    }
+}
+
+bool ViewProperties::sortFoldersFirst() const
+{
+    return m_node->sortFoldersFirst();
+}
+
+void ViewProperties::setAdditionalInfo(const KFileItemDelegate::InformationList& list)
+{
+    AdditionalInfoAccessor& infoAccessor = AdditionalInfoAccessor::instance();
+
+    int infoMask = 0;
+    foreach (KFileItemDelegate::Information currentInfo, list) {
+        infoMask = infoMask | infoAccessor.bitValue(currentInfo);
+    }
+
+    const int encodedInfo = encodedAdditionalInfo(infoMask);
+    if (m_node->additionalInfo() != encodedInfo) {
+        m_node->setAdditionalInfo(encodedInfo);
+        updateTimeStamp();
+    }
+}
+
+KFileItemDelegate::InformationList ViewProperties::additionalInfo() const
+{
+    KFileItemDelegate::InformationList usedInfos;
+
+    const int decodedInfo = decodedAdditionalInfo();
+
+    AdditionalInfoAccessor& infoAccessor = AdditionalInfoAccessor::instance();
+    const KFileItemDelegate::InformationList infos = infoAccessor.keys();
+
+    foreach (const KFileItemDelegate::Information info, infos) {
+        if (decodedInfo & infoAccessor.bitValue(info)) {
+            usedInfos.append(info);
+        }
+    }
+
+    return usedInfos;
+}
+
+
+void ViewProperties::setDirProperties(const ViewProperties& props)
+{
+    setViewMode(props.viewMode());
+    setShowPreview(props.showPreview());
+    setShowHiddenFiles(props.showHiddenFiles());
+    setCategorizedSorting(props.categorizedSorting());
+    setSorting(props.sorting());
+    setSortOrder(props.sortOrder());
+    setSortFoldersFirst(props.sortFoldersFirst());
+    setAdditionalInfo(props.additionalInfo());
+}
+
+void ViewProperties::setAutoSaveEnabled(bool autoSave)
+{
+    m_autoSave = autoSave;
+}
+
+bool ViewProperties::isAutoSaveEnabled() const
+{
+    return m_autoSave;
+}
+
+void ViewProperties::updateTimeStamp()
+{
+    m_changedProps = true;
+    m_node->setTimestamp(QDateTime::currentDateTime());
+}
+
+void ViewProperties::save()
+{
+    KStandardDirs::makeDir(m_filePath);
+    m_node->writeConfig();
+    m_changedProps = false;
+}
+
+KUrl ViewProperties::mirroredDirectory()
+{
+    QString basePath = KGlobal::mainComponent().componentName();
+    basePath.append("/view_properties/");
+    return KUrl(KStandardDirs::locateLocal("data", basePath));
+}
+
+QString ViewProperties::destinationDir(const QString& subDir) const
+{
+    QString basePath = KGlobal::mainComponent().componentName();
+    basePath.append("/view_properties/").append(subDir);
+    return KStandardDirs::locateLocal("data", basePath);
+}
+
+int ViewProperties::encodedAdditionalInfo(int info) const
+{
+    int encodedInfo = m_node->additionalInfo();
+
+    switch (viewMode()) {
+    case DolphinView::DetailsView:
+        encodedInfo = (encodedInfo & 0xFFFF00) | info;
+        break;
+    case DolphinView::IconsView:
+        encodedInfo = (encodedInfo & 0xFF00FF) | (info << 8);
+        break;
+    case DolphinView::ColumnView:
+        encodedInfo = (encodedInfo & 0x00FFFF) | (info << 16);
+        break;
+    default: break;
+    }
+
+    return encodedInfo;
+}
+
+int ViewProperties::decodedAdditionalInfo() const
+{
+    int decodedInfo = m_node->additionalInfo();
+
+    switch (viewMode()) {
+    case DolphinView::DetailsView:
+        decodedInfo = decodedInfo & 0xFF;
+        if (decodedInfo == 0) {
+            // A details view without any additional info makes no sense, hence
+            // provide at least a size-info and date-info as fallback
+            AdditionalInfoAccessor& infoAccessor = AdditionalInfoAccessor::instance();
+            decodedInfo = infoAccessor.bitValue(KFileItemDelegate::Size) |
+                          infoAccessor.bitValue(KFileItemDelegate::ModificationTime);
+        }
+        break;
+    case DolphinView::IconsView:
+        decodedInfo = (decodedInfo >> 8) & 0xFF;
+        break;
+    case DolphinView::ColumnView:
+        decodedInfo = (decodedInfo >> 16) & 0xFF;
+        break;
+    default: break;
+    }
+
+    return decodedInfo;
+}
diff --git a/src/views/viewproperties.h b/src/views/viewproperties.h
new file mode 100644
index 000000000..bb476dc44
--- /dev/null
+++ b/src/views/viewproperties.h
@@ -0,0 +1,163 @@
+/***************************************************************************
+ *   Copyright (C) 2006-2010 by Peter Penz <[email protected]>             *
+ *   Copyright (C) 2006 by Aaron J. Seigo <[email protected]>                 *
+ *                                                                         *
+ *   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          *
+ ***************************************************************************/
+
+#ifndef VIEWPROPERTIES_H
+#define VIEWPROPERTIES_H
+
+#include <views/dolphinview.h>
+#include <kurl.h>
+#include <libdolphin_export.h>
+
+class ViewPropertySettings;
+/**
+ * @brief Maintains the view properties like 'view mode' or
+ *        'show hidden files' for a directory.
+ *
+ * The view properties are automatically stored as part of the file
+ * .directory inside the corresponding path. To read out the view properties
+ * just construct an instance by passing the path of the directory:
+ *
+ * \code
+ * ViewProperties props(KUrl("/home/peter/Documents"));
+ * const DolphinView::Mode mode = props.viewMode();
+ * const bool showHiddenFiles = props.isShowHiddenFilesEnabled();
+ * \endcode
+ *
+ * When modifying a view property, the '.directory' file is automatically updated
+ * inside the destructor.
+ *
+ * If no .directory file is available or the global view mode is turned on
+ * (see GeneralSettings::globalViewMode()), the values from the global .directory file
+ * are used for initialization.
+ */
+class LIBDOLPHINPRIVATE_EXPORT ViewProperties
+{
+public:
+    explicit ViewProperties(const KUrl& url);
+    virtual ~ViewProperties();
+
+    void setViewMode(DolphinView::Mode mode);
+    DolphinView::Mode viewMode() const;
+
+    void setShowPreview(bool show);
+    bool showPreview() const;
+
+    void setShowHiddenFiles(bool show);
+    bool showHiddenFiles() const;
+
+    void setCategorizedSorting(bool categorized);
+    bool categorizedSorting() const;
+
+    void setSorting(DolphinView::Sorting sorting);
+    DolphinView::Sorting sorting() const;
+
+    void setSortOrder(Qt::SortOrder sortOrder);
+    Qt::SortOrder sortOrder() const;
+
+    void setSortFoldersFirst(bool foldersFirst);
+    bool sortFoldersFirst() const;
+
+    /**
+     * Sets the additional information for the current set view-mode.
+     * Note that the additional-info property is the only property where
+     * the value is dependent from another property (in this case the view-mode).
+     */
+    void setAdditionalInfo(const KFileItemDelegate::InformationList& info);
+
+    /**
+     * Returns the additional information for the current set view-mode.
+     * Note that the additional-info property is the only property where
+     * the value is dependent from another property (in this case the view-mode).
+     */
+    KFileItemDelegate::InformationList additionalInfo() const;
+
+    /**
+     * Sets the directory properties view mode, show preview,
+     * show hidden files, sorting and sort order like
+     * set in \a props.
+     */
+    void setDirProperties(const ViewProperties& props);
+
+    /**
+     * If \a autoSave is true, the properties are automatically
+     * saved when the destructor is called. Per default autosaving
+     * is enabled.
+     */
+    void setAutoSaveEnabled(bool autoSave);
+    bool isAutoSaveEnabled() const;
+
+    void updateTimeStamp();
+
+    /**
+     * Saves the view properties for the directory specified
+     * in the constructor. The method is automatically
+     * invoked in the destructor, if
+     * ViewProperties::isAutoSaveEnabled() returns true and
+     * at least one property has been changed.
+     */
+    void save();
+
+    /**
+     * Returns the URL of the directory, where the mirrored view properties
+     * are stored into. Mirrored view properties are used if:
+     * - there is no write access for storing the view properties into
+     *   the original directory
+     * - for non local directories
+     */
+    static KUrl mirroredDirectory();
+
+private:
+    /**
+     * Returns the destination directory path where the view
+     * properties are stored. \a subDir specifies the used sub
+     * directory.
+     */
+    QString destinationDir(const QString& subDir) const;
+
+    /**
+     * Returns the encoded additional information that can be stored
+     * in the .directory file. See ViewProperties::decodedAdditionalInfo()
+     * for the coding format.
+     * @param info   Additional information for the current view mode.
+     */
+    int encodedAdditionalInfo(int info) const;
+
+    /**
+     * Returns the decoded additional information from the .directory
+     * file by respecting the current set view mode. The additional
+     * information from the .directory file is an integer value, where:
+     * - Byte 0 stores the additional info for the details view
+     * - Byte 1 stores the additional info for the icons view
+     * - Byte 2 stores the additional info for the column view
+     * The additional information property is the only property that is
+     * dependent from another property (in this case the view-mode).
+     */
+    int decodedAdditionalInfo() const;
+
+    Q_DISABLE_COPY(ViewProperties)
+
+private:
+    bool m_changedProps;
+    bool m_autoSave;
+    QString m_filePath;
+    ViewPropertySettings* m_node;
+};
+
+#endif