diff --git a/src/kitemviews/kitemlistcontroller.cpp b/src/kitemviews/kitemlistcontroller.cpp
index 3731895d0..753d7915d 100644
--- a/src/kitemviews/kitemlistcontroller.cpp
+++ b/src/kitemviews/kitemlistcontroller.cpp
@@ -1,1328 +1,1332 @@
 /***************************************************************************
  *   Copyright (C) 2011 by Peter Penz <peter.penz19@gmail.com>             *
  *   Copyright (C) 2012 by Frank Reininghaus <frank78ac@googlemail.com>    *
  *                                                                         *
  *   Based on the Itemviews NG project from Trolltech Labs:                *
  *   http://qt.gitorious.org/qt-labs/itemviews-ng                          *
  *                                                                         *
  *   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 "kitemlistcontroller.h"
 
 
 #include "kitemlistview.h"
 #include "kitemlistselectionmanager.h"
 
 #include "private/kitemlistrubberband.h"
 #include "private/kitemlistkeyboardsearchmanager.h"
 
 #include <QApplication>
 #include <QDrag>
 #include <QEvent>
 #include <QGraphicsScene>
 #include <QGraphicsSceneEvent>
 #include <QGraphicsView>
 #include <QMimeData>
 #include <QTimer>
 #include <QAccessible>
 
 KItemListController::KItemListController(KItemModelBase* model, KItemListView* view, QObject* parent) :
     QObject(parent),
     m_singleClickActivationEnforced(false),
     m_selectionTogglePressed(false),
     m_clearSelectionIfItemsAreNotDragged(false),
     m_selectionBehavior(NoSelection),
     m_autoActivationBehavior(ActivationAndExpansion),
     m_mouseDoubleClickAction(ActivateItemOnly),
     m_model(0),
     m_view(0),
     m_selectionManager(new KItemListSelectionManager(this)),
     m_keyboardManager(new KItemListKeyboardSearchManager(this)),
     m_pressedIndex(-1),
     m_pressedMousePos(),
     m_autoActivationTimer(0),
     m_oldSelection(),
     m_keyboardAnchorIndex(-1),
     m_keyboardAnchorPos(0)
 {
     connect(m_keyboardManager, &KItemListKeyboardSearchManager::changeCurrentItem,
             this, &KItemListController::slotChangeCurrentItem);
     connect(m_selectionManager, &KItemListSelectionManager::currentChanged,
             m_keyboardManager, &KItemListKeyboardSearchManager::slotCurrentChanged);
 
     m_autoActivationTimer = new QTimer(this);
     m_autoActivationTimer->setSingleShot(true);
     m_autoActivationTimer->setInterval(-1);
     connect(m_autoActivationTimer, &QTimer::timeout, this, &KItemListController::slotAutoActivationTimeout);
 
     setModel(model);
     setView(view);
 }
 
 KItemListController::~KItemListController()
 {
     setView(0);
     Q_ASSERT(!m_view);
 
     setModel(0);
     Q_ASSERT(!m_model);
 }
 
 void KItemListController::setModel(KItemModelBase* model)
 {
     if (m_model == model) {
         return;
     }
 
     KItemModelBase* oldModel = m_model;
     if (oldModel) {
         oldModel->deleteLater();
     }
 
     m_model = model;
     if (m_model) {
         m_model->setParent(this);
     }
 
     if (m_view) {
         m_view->setModel(m_model);
     }
 
     m_selectionManager->setModel(m_model);
 
     emit modelChanged(m_model, oldModel);
 }
 
 KItemModelBase* KItemListController::model() const
 {
     return m_model;
 }
 
 KItemListSelectionManager* KItemListController::selectionManager() const
 {
     return m_selectionManager;
 }
 
 void KItemListController::setView(KItemListView* view)
 {
     if (m_view == view) {
         return;
     }
 
     KItemListView* oldView = m_view;
     if (oldView) {
         disconnect(oldView, &KItemListView::scrollOffsetChanged, this, &KItemListController::slotViewScrollOffsetChanged);
         oldView->deleteLater();
     }
 
     m_view = view;
 
     if (m_view) {
         m_view->setParent(this);
         m_view->setController(this);
         m_view->setModel(m_model);
         connect(m_view, &KItemListView::scrollOffsetChanged, this, &KItemListController::slotViewScrollOffsetChanged);
         updateExtendedSelectionRegion();
     }
 
     emit viewChanged(m_view, oldView);
 }
 
 KItemListView* KItemListController::view() const
 {
     return m_view;
 }
 
 void KItemListController::setSelectionBehavior(SelectionBehavior behavior)
 {
     m_selectionBehavior = behavior;
     updateExtendedSelectionRegion();
 }
 
 KItemListController::SelectionBehavior KItemListController::selectionBehavior() const
 {
     return m_selectionBehavior;
 }
 
 void KItemListController::setAutoActivationBehavior(AutoActivationBehavior behavior)
 {
     m_autoActivationBehavior = behavior;
 }
 
 KItemListController::AutoActivationBehavior KItemListController::autoActivationBehavior() const
 {
     return m_autoActivationBehavior;
 }
 
 void KItemListController::setMouseDoubleClickAction(MouseDoubleClickAction action)
 {
     m_mouseDoubleClickAction = action;
 }
 
 KItemListController::MouseDoubleClickAction KItemListController::mouseDoubleClickAction() const
 {
     return m_mouseDoubleClickAction;
 }
 
 void KItemListController::setAutoActivationDelay(int delay)
 {
     m_autoActivationTimer->setInterval(delay);
 }
 
 int KItemListController::autoActivationDelay() const
 {
     return m_autoActivationTimer->interval();
 }
 
 void KItemListController::setSingleClickActivationEnforced(bool singleClick)
 {
     m_singleClickActivationEnforced = singleClick;
 }
 
 bool KItemListController::singleClickActivationEnforced() const
 {
     return m_singleClickActivationEnforced;
 }
 
 bool KItemListController::showEvent(QShowEvent* event)
 {
     Q_UNUSED(event);
     return false;
 }
 
 bool KItemListController::hideEvent(QHideEvent* event)
 {
     Q_UNUSED(event);
     return false;
 }
 
 bool KItemListController::keyPressEvent(QKeyEvent* event)
 {
     int index = m_selectionManager->currentItem();
     int key = event->key();
 
     // Handle the expanding/collapsing of items
     if (m_view->supportsItemExpanding() && m_model->isExpandable(index)) {
         if (key == Qt::Key_Right) {
             if (m_model->setExpanded(index, true)) {
                 return true;
             }
         } else if (key == Qt::Key_Left) {
             if (m_model->setExpanded(index, false)) {
                 return true;
             }
         }
     }
 
     const bool shiftPressed = event->modifiers() & Qt::ShiftModifier;
     const bool controlPressed = event->modifiers() & Qt::ControlModifier;
     const bool shiftOrControlPressed = shiftPressed || controlPressed;
 
     const int itemCount = m_model->count();
 
     // For horizontal scroll orientation, transform
     // the arrow keys to simplify the event handling.
     if (m_view->scrollOrientation() == Qt::Horizontal) {
         switch (key) {
         case Qt::Key_Up:    key = Qt::Key_Left; break;
         case Qt::Key_Down:  key = Qt::Key_Right; break;
         case Qt::Key_Left:  key = Qt::Key_Up; break;
         case Qt::Key_Right: key = Qt::Key_Down; break;
         default:            break;
         }
     }
 
     const bool selectSingleItem = m_selectionBehavior != NoSelection &&
                                   itemCount == 1 &&
                                   (key == Qt::Key_Home || key == Qt::Key_End  ||
                                    key == Qt::Key_Up   || key == Qt::Key_Down ||
                                    key == Qt::Key_Left || key == Qt::Key_Right);
     if (selectSingleItem) {
         const int current = m_selectionManager->currentItem();
         m_selectionManager->setSelected(current);
         return true;
     }
 
     switch (key) {
     case Qt::Key_Home:
         index = 0;
         m_keyboardAnchorIndex = index;
         m_keyboardAnchorPos = keyboardAnchorPos(index);
         break;
 
     case Qt::Key_End:
         index = itemCount - 1;
         m_keyboardAnchorIndex = index;
         m_keyboardAnchorPos = keyboardAnchorPos(index);
         break;
 
     case Qt::Key_Left:
         if (index > 0) {
             const int expandedParentsCount = m_model->expandedParentsCount(index);
             if (expandedParentsCount == 0) {
                 --index;
             } else {
                 // Go to the parent of the current item.
                 do {
                     --index;
                 } while (index > 0 && m_model->expandedParentsCount(index) == expandedParentsCount);
             }
             m_keyboardAnchorIndex = index;
             m_keyboardAnchorPos = keyboardAnchorPos(index);
         }
         break;
 
     case Qt::Key_Right:
         if (index < itemCount - 1) {
             ++index;
             m_keyboardAnchorIndex = index;
             m_keyboardAnchorPos = keyboardAnchorPos(index);
         }
         break;
 
     case Qt::Key_Up:
         updateKeyboardAnchor();
         index = previousRowIndex(index);
         break;
 
     case Qt::Key_Down:
         updateKeyboardAnchor();
         index = nextRowIndex(index);
         break;
 
     case Qt::Key_PageUp:
         if (m_view->scrollOrientation() == Qt::Horizontal) {
             // The new current index should correspond to the first item in the current column.
             int newIndex = qMax(index - 1, 0);
             while (newIndex != index && m_view->itemRect(newIndex).topLeft().y() < m_view->itemRect(index).topLeft().y()) {
                 index = newIndex;
                 newIndex = qMax(index - 1, 0);
             }
             m_keyboardAnchorIndex = index;
             m_keyboardAnchorPos = keyboardAnchorPos(index);
         } else {
             const qreal currentItemBottom = m_view->itemRect(index).bottomLeft().y();
             const qreal height = m_view->geometry().height();
 
             // The new current item should be the first item in the current
             // column whose itemRect's top coordinate is larger than targetY.
             const qreal targetY = currentItemBottom - height;
 
             updateKeyboardAnchor();
             int newIndex = previousRowIndex(index);
             do {
                 index = newIndex;
                 updateKeyboardAnchor();
                 newIndex = previousRowIndex(index);
             } while (m_view->itemRect(newIndex).topLeft().y() > targetY && newIndex != index);
         }
         break;
 
     case Qt::Key_PageDown:
         if (m_view->scrollOrientation() == Qt::Horizontal) {
             // The new current index should correspond to the last item in the current column.
             int newIndex = qMin(index + 1, m_model->count() - 1);
             while (newIndex != index && m_view->itemRect(newIndex).topLeft().y() > m_view->itemRect(index).topLeft().y()) {
                 index = newIndex;
                 newIndex = qMin(index + 1, m_model->count() - 1);
             }
             m_keyboardAnchorIndex = index;
             m_keyboardAnchorPos = keyboardAnchorPos(index);
         } else {
             const qreal currentItemTop = m_view->itemRect(index).topLeft().y();
             const qreal height = m_view->geometry().height();
 
             // The new current item should be the last item in the current
             // column whose itemRect's bottom coordinate is smaller than targetY.
             const qreal targetY = currentItemTop + height;
 
             updateKeyboardAnchor();
             int newIndex = nextRowIndex(index);
             do {
                 index = newIndex;
                 updateKeyboardAnchor();
                 newIndex = nextRowIndex(index);
             } while (m_view->itemRect(newIndex).bottomLeft().y() < targetY && newIndex != index);
         }
         break;
 
     case Qt::Key_Enter:
     case Qt::Key_Return: {
         const KItemSet selectedItems = m_selectionManager->selectedItems();
         if (selectedItems.count() >= 2) {
             emit itemsActivated(selectedItems);
         } else if (selectedItems.count() == 1) {
             emit itemActivated(selectedItems.first());
         } else {
             emit itemActivated(index);
         }
         break;
     }
 
     case Qt::Key_Menu: {
         // Emit the signal itemContextMenuRequested() in case if at least one
         // item is selected. Otherwise the signal viewContextMenuRequested() will be emitted.
         const KItemSet selectedItems = m_selectionManager->selectedItems();
         int index = -1;
         if (selectedItems.count() >= 2) {
             const int currentItemIndex = m_selectionManager->currentItem();
             index = selectedItems.contains(currentItemIndex)
                     ? currentItemIndex : selectedItems.first();
         } else if (selectedItems.count() == 1) {
             index = selectedItems.first();
         }
 
         if (index >= 0) {
             const QRectF contextRect = m_view->itemContextRect(index);
             const QPointF pos(m_view->scene()->views().first()->mapToGlobal(contextRect.bottomRight().toPoint()));
             emit itemContextMenuRequested(index, pos);
         } else {
             emit viewContextMenuRequested(QCursor::pos());
         }
         break;
     }
 
     case Qt::Key_Escape:
         if (m_selectionBehavior != SingleSelection) {
             m_selectionManager->clearSelection();
         }
         m_keyboardManager->cancelSearch();
         emit escapePressed();
         break;
 
     case Qt::Key_Space:
         if (m_selectionBehavior == MultiSelection) {
             if (controlPressed) {
                 // Toggle the selection state of the current item.
                 m_selectionManager->endAnchoredSelection();
                 m_selectionManager->setSelected(index, 1, KItemListSelectionManager::Toggle);
                 m_selectionManager->beginAnchoredSelection(index);
                 break;
             } else {
                 // Select the current item if it is not selected yet.
                 const int current = m_selectionManager->currentItem();
                 if (!m_selectionManager->isSelected(current)) {
                     m_selectionManager->setSelected(current);
                     break;
                 }
             }
         }
         // Fall through to the default case and add the Space to the current search string.
 
     default:
         m_keyboardManager->addKeys(event->text());
         // Make sure unconsumed events get propagated up the chain. #302329
         event->ignore();
         return false;
     }
 
     if (m_selectionManager->currentItem() != index) {
         switch (m_selectionBehavior) {
         case NoSelection:
             m_selectionManager->setCurrentItem(index);
             break;
 
         case SingleSelection:
             m_selectionManager->setCurrentItem(index);
             m_selectionManager->clearSelection();
             m_selectionManager->setSelected(index, 1);
             break;
 
         case MultiSelection:
             if (controlPressed) {
                 m_selectionManager->endAnchoredSelection();
             }
 
             m_selectionManager->setCurrentItem(index);
 
             if (!shiftOrControlPressed) {
                 m_selectionManager->clearSelection();
                 m_selectionManager->setSelected(index, 1);
             }
 
             if (!shiftPressed) {
                 m_selectionManager->beginAnchoredSelection(index);
             }
             break;
         }
 
         m_view->scrollToItem(index);
     }
     return true;
 }
 
 void KItemListController::slotChangeCurrentItem(const QString& text, bool searchFromNextItem)
 {
     if (!m_model || m_model->count() == 0) {
         return;
     }
     const int currentIndex = m_selectionManager->currentItem();
     int index;
     if (searchFromNextItem) {
         index = m_model->indexForKeyboardSearch(text, (currentIndex + 1) % m_model->count());
     } else {
         index = m_model->indexForKeyboardSearch(text, currentIndex);
     }
     if (index >= 0) {
         m_selectionManager->setCurrentItem(index);
 
         if (m_selectionBehavior != NoSelection) {
             m_selectionManager->clearSelection();
             m_selectionManager->setSelected(index, 1);
             m_selectionManager->beginAnchoredSelection(index);
         }
 
         m_view->scrollToItem(index);
     }
 }
 
 void KItemListController::slotAutoActivationTimeout()
 {
     if (!m_model || !m_view) {
         return;
     }
 
     const int index = m_autoActivationTimer->property("index").toInt();
     if (index < 0 || index >= m_model->count()) {
         return;
     }
 
     /* m_view->isUnderMouse() fixes a bug in the Folder-View-Panel and in the
      * Places-Panel.
      *
      * Bug: When you drag a file onto a Folder-View-Item or a Places-Item and
      * then move away before the auto-activation timeout triggers, than the
      * item still becomes activated/expanded.
      *
      * See Bug 293200 and 305783
      */
     if (m_model->supportsDropping(index) && m_view->isUnderMouse()) {
         if (m_view->supportsItemExpanding() && m_model->isExpandable(index)) {
             const bool expanded = m_model->isExpanded(index);
             m_model->setExpanded(index, !expanded);
         } else if (m_autoActivationBehavior != ExpansionOnly) {
             emit itemActivated(index);
         }
     }
 }
 
 bool KItemListController::inputMethodEvent(QInputMethodEvent* event)
 {
     Q_UNUSED(event);
     return false;
 }
 
 bool KItemListController::mousePressEvent(QGraphicsSceneMouseEvent* event, const QTransform& transform)
 {
     if (!m_view) {
         return false;
     }
 
     m_pressedMousePos = transform.map(event->pos());
     m_pressedIndex = m_view->itemAt(m_pressedMousePos);
     emit mouseButtonPressed(m_pressedIndex, event->buttons());
 
     if (event->buttons() & (Qt::BackButton | Qt::ForwardButton)) {
         // Do not select items when clicking the back/forward buttons, see
         // https://bugs.kde.org/show_bug.cgi?id=327412.
         return true;
     }
 
     if (m_view->isAboveExpansionToggle(m_pressedIndex, m_pressedMousePos)) {
         m_selectionManager->endAnchoredSelection();
         m_selectionManager->setCurrentItem(m_pressedIndex);
         m_selectionManager->beginAnchoredSelection(m_pressedIndex);
         return true;
     }
 
     m_selectionTogglePressed = m_view->isAboveSelectionToggle(m_pressedIndex, m_pressedMousePos);
     if (m_selectionTogglePressed) {
         m_selectionManager->setSelected(m_pressedIndex, 1, KItemListSelectionManager::Toggle);
         // The previous anchored selection has been finished already in
         // KItemListSelectionManager::setSelected(). We can safely change
         // the current item and start a new anchored selection now.
         m_selectionManager->setCurrentItem(m_pressedIndex);
         m_selectionManager->beginAnchoredSelection(m_pressedIndex);
         return true;
     }
 
     const bool shiftPressed = event->modifiers() & Qt::ShiftModifier;
     const bool controlPressed = event->modifiers() & Qt::ControlModifier;
 
     // The previous selection is cleared if either
     // 1. The selection mode is SingleSelection, or
     // 2. the selection mode is MultiSelection, and *none* of the following conditions are met:
     //    a) Shift or Control are pressed.
     //    b) The clicked item is selected already. In that case, the user might want to:
     //       - start dragging multiple items, or
     //       - open the context menu and perform an action for all selected items.
     const bool shiftOrControlPressed = shiftPressed || controlPressed;
     const bool pressedItemAlreadySelected = m_pressedIndex >= 0 && m_selectionManager->isSelected(m_pressedIndex);
     const bool clearSelection = m_selectionBehavior == SingleSelection ||
                                 (!shiftOrControlPressed && !pressedItemAlreadySelected);
     if (clearSelection) {
         m_selectionManager->clearSelection();
     } else if (pressedItemAlreadySelected && !shiftOrControlPressed && (event->buttons() & Qt::LeftButton)) {
         // The user might want to start dragging multiple items, but if he clicks the item
         // in order to trigger it instead, the other selected items must be deselected.
         // However, we do not know yet what the user is going to do.
         // -> remember that the user pressed an item which had been selected already and
         //    clear the selection in mouseReleaseEvent(), unless the items are dragged.
         m_clearSelectionIfItemsAreNotDragged = true;
+
+        if (m_selectionManager->selectedItems().count() == 1 && m_view->isAboveText(m_pressedIndex, m_pressedMousePos)) {
+            emit selectedItemTextPressed(m_pressedIndex);
+        }
     }
 
     if (!shiftPressed) {
         // Finish the anchored selection before the current index is changed
         m_selectionManager->endAnchoredSelection();
     }
 
     if (m_pressedIndex >= 0) {
         m_selectionManager->setCurrentItem(m_pressedIndex);
 
         switch (m_selectionBehavior) {
         case NoSelection:
             break;
 
         case SingleSelection:
             m_selectionManager->setSelected(m_pressedIndex);
             break;
 
         case MultiSelection:
             if (controlPressed && !shiftPressed) {
                 m_selectionManager->setSelected(m_pressedIndex, 1, KItemListSelectionManager::Toggle);
                 m_selectionManager->beginAnchoredSelection(m_pressedIndex);
             } else if (!shiftPressed || !m_selectionManager->isAnchoredSelectionActive()) {
                 // Select the pressed item and start a new anchored selection
                 m_selectionManager->setSelected(m_pressedIndex, 1, KItemListSelectionManager::Select);
                 m_selectionManager->beginAnchoredSelection(m_pressedIndex);
             }
             break;
 
         default:
             Q_ASSERT(false);
             break;
         }
 
         if (event->buttons() & Qt::RightButton) {
             emit itemContextMenuRequested(m_pressedIndex, event->screenPos());
         }
 
         return true;
     }
 
     if (event->buttons() & Qt::RightButton) {
         const QRectF headerBounds = m_view->headerBoundaries();
         if (headerBounds.contains(event->pos())) {
             emit headerContextMenuRequested(event->screenPos());
         } else {
             emit viewContextMenuRequested(event->screenPos());
         }
         return true;
     }
 
     if (m_selectionBehavior == MultiSelection) {
         QPointF startPos = m_pressedMousePos;
         if (m_view->scrollOrientation() == Qt::Vertical) {
             startPos.ry() += m_view->scrollOffset();
             if (m_view->itemSize().width() < 0) {
                 // Use a special rubberband for views that have only one column and
                 // expand the rubberband to use the whole width of the view.
                 startPos.setX(0);
             }
         } else {
             startPos.rx() += m_view->scrollOffset();
         }
 
         m_oldSelection = m_selectionManager->selectedItems();
         KItemListRubberBand* rubberBand = m_view->rubberBand();
         rubberBand->setStartPosition(startPos);
         rubberBand->setEndPosition(startPos);
         rubberBand->setActive(true);
         connect(rubberBand, &KItemListRubberBand::endPositionChanged, this, &KItemListController::slotRubberBandChanged);
         m_view->setAutoScroll(true);
     }
 
     return false;
 }
 
 bool KItemListController::mouseMoveEvent(QGraphicsSceneMouseEvent* event, const QTransform& transform)
 {
     if (!m_view) {
         return false;
     }
 
     if (m_pressedIndex >= 0) {
         // Check whether a dragging should be started
         if (event->buttons() & Qt::LeftButton) {
             const QPointF pos = transform.map(event->pos());
             if ((pos - m_pressedMousePos).manhattanLength() >= QApplication::startDragDistance()) {
                 if (!m_selectionManager->isSelected(m_pressedIndex)) {
                     // Always assure that the dragged item gets selected. Usually this is already
                     // done on the mouse-press event, but when using the selection-toggle on a
                     // selected item the dragged item is not selected yet.
                     m_selectionManager->setSelected(m_pressedIndex, 1, KItemListSelectionManager::Toggle);
                 } else {
                     // A selected item has been clicked to drag all selected items
                     // -> the selection should not be cleared when the mouse button is released.
                     m_clearSelectionIfItemsAreNotDragged = false;
                 }
 
                 startDragging();
             }
         }
     } else {
         KItemListRubberBand* rubberBand = m_view->rubberBand();
         if (rubberBand->isActive()) {
             QPointF endPos = transform.map(event->pos());
 
             // Update the current item.
             const int newCurrent = m_view->itemAt(endPos);
             if (newCurrent >= 0) {
                 // It's expected that the new current index is also the new anchor (bug 163451).
                 m_selectionManager->endAnchoredSelection();
                 m_selectionManager->setCurrentItem(newCurrent);
                 m_selectionManager->beginAnchoredSelection(newCurrent);
             }
 
             if (m_view->scrollOrientation() == Qt::Vertical) {
                 endPos.ry() += m_view->scrollOffset();
                 if (m_view->itemSize().width() < 0) {
                     // Use a special rubberband for views that have only one column and
                     // expand the rubberband to use the whole width of the view.
                     endPos.setX(m_view->size().width());
                 }
             } else {
                 endPos.rx() += m_view->scrollOffset();
             }
             rubberBand->setEndPosition(endPos);
         }
     }
 
     return false;
 }
 
 bool KItemListController::mouseReleaseEvent(QGraphicsSceneMouseEvent* event, const QTransform& transform)
 {
     if (!m_view) {
         return false;
     }
 
     emit mouseButtonReleased(m_pressedIndex, event->buttons());
 
     const bool isAboveSelectionToggle = m_view->isAboveSelectionToggle(m_pressedIndex, m_pressedMousePos);
     if (isAboveSelectionToggle) {
         m_selectionTogglePressed = false;
         return true;
     }
 
     if (!isAboveSelectionToggle && m_selectionTogglePressed) {
         m_selectionManager->setSelected(m_pressedIndex, 1, KItemListSelectionManager::Toggle);
         m_selectionTogglePressed = false;
         return true;
     }
 
     const bool shiftOrControlPressed = event->modifiers() & Qt::ShiftModifier ||
                                        event->modifiers() & Qt::ControlModifier;
 
     KItemListRubberBand* rubberBand = m_view->rubberBand();
     if (rubberBand->isActive()) {
         disconnect(rubberBand, &KItemListRubberBand::endPositionChanged, this, &KItemListController::slotRubberBandChanged);
         rubberBand->setActive(false);
         m_oldSelection.clear();
         m_view->setAutoScroll(false);
     }
 
     const QPointF pos = transform.map(event->pos());
     const int index = m_view->itemAt(pos);
 
     if (index >= 0 && index == m_pressedIndex) {
         // The release event is done above the same item as the press event
 
         if (m_clearSelectionIfItemsAreNotDragged) {
             // A selected item has been clicked, but no drag operation has been started
             // -> clear the rest of the selection.
             m_selectionManager->clearSelection();
             m_selectionManager->setSelected(m_pressedIndex, 1, KItemListSelectionManager::Select);
             m_selectionManager->beginAnchoredSelection(m_pressedIndex);
         }
 
         if (event->button() & Qt::LeftButton) {
             bool emitItemActivated = true;
             if (m_view->isAboveExpansionToggle(index, pos)) {
                 const bool expanded = m_model->isExpanded(index);
                 m_model->setExpanded(index, !expanded);
 
                 emit itemExpansionToggleClicked(index);
                 emitItemActivated = false;
             } else if (shiftOrControlPressed) {
                 // The mouse click should only update the selection, not trigger the item
                 emitItemActivated = false;
             } else if (!(m_view->style()->styleHint(QStyle::SH_ItemView_ActivateItemOnSingleClick) || m_singleClickActivationEnforced)) {
                 emitItemActivated = false;
             }
             if (emitItemActivated) {
                 emit itemActivated(index);
             }
         } else if (event->button() & Qt::MidButton) {
             emit itemMiddleClicked(index);
         }
     }
 
     m_pressedMousePos = QPointF();
     m_pressedIndex = -1;
     m_clearSelectionIfItemsAreNotDragged = false;
     return false;
 }
 
 bool KItemListController::mouseDoubleClickEvent(QGraphicsSceneMouseEvent* event, const QTransform& transform)
 {
     const QPointF pos = transform.map(event->pos());
     const int index = m_view->itemAt(pos);
 
     // Expand item if desired - See Bug 295573
     if (m_mouseDoubleClickAction != ActivateItemOnly) {
         if (m_view && m_model && m_view->supportsItemExpanding() && m_model->isExpandable(index)) {
             const bool expanded = m_model->isExpanded(index);
             m_model->setExpanded(index, !expanded);
         }
     }
 
     if (event->button() & Qt::RightButton) {
         m_selectionManager->clearSelection();
         if (index >= 0) {
             m_selectionManager->setSelected(index);
             emit itemContextMenuRequested(index, event->screenPos());
         } else {
             const QRectF headerBounds = m_view->headerBoundaries();
             if (headerBounds.contains(event->pos())) {
                 emit headerContextMenuRequested(event->screenPos());
             } else {
                 emit viewContextMenuRequested(event->screenPos());
             }
         }
         return true;
     }
 
     bool emitItemActivated = !(m_view->style()->styleHint(QStyle::SH_ItemView_ActivateItemOnSingleClick) || m_singleClickActivationEnforced) &&
                              (event->button() & Qt::LeftButton) &&
                              index >= 0 && index < m_model->count();
     if (emitItemActivated) {
         emit itemActivated(index);
     }
     return false;
 }
 
 bool KItemListController::dragEnterEvent(QGraphicsSceneDragDropEvent* event, const QTransform& transform)
 {
     Q_UNUSED(event);
     Q_UNUSED(transform);
     return false;
 }
 
 bool KItemListController::dragLeaveEvent(QGraphicsSceneDragDropEvent* event, const QTransform& transform)
 {
     Q_UNUSED(event);
     Q_UNUSED(transform);
 
     m_view->setAutoScroll(false);
     m_view->hideDropIndicator();
 
     KItemListWidget* widget = hoveredWidget();
     if (widget) {
         widget->setHovered(false);
         emit itemUnhovered(widget->index());
     }
     return false;
 }
 
 bool KItemListController::dragMoveEvent(QGraphicsSceneDragDropEvent* event, const QTransform& transform)
 {
     if (!m_model || !m_view) {
         return false;
     }
 
     event->acceptProposedAction();
 
     KItemListWidget* oldHoveredWidget = hoveredWidget();
 
     const QPointF pos = transform.map(event->pos());
     KItemListWidget* newHoveredWidget = widgetForPos(pos);
 
     if (oldHoveredWidget != newHoveredWidget) {
         m_autoActivationTimer->stop();
 
         if (oldHoveredWidget) {
             oldHoveredWidget->setHovered(false);
             emit itemUnhovered(oldHoveredWidget->index());
         }
     }
 
     if (newHoveredWidget) {
         bool droppingBetweenItems = false;
         if (m_model->sortRole().isEmpty()) {
             // The model supports inserting items between other items.
             droppingBetweenItems = (m_view->showDropIndicator(pos) >= 0);
         }
 
         const int index = newHoveredWidget->index();
         if (!droppingBetweenItems) {
             if (m_model->supportsDropping(index)) {
                 // Something has been dragged on an item.
                 m_view->hideDropIndicator();
                 if (!newHoveredWidget->isHovered()) {
                     newHoveredWidget->setHovered(true);
                     emit itemHovered(index);
                 }
 
                 if (!m_autoActivationTimer->isActive() && m_autoActivationTimer->interval() >= 0) {
                     m_autoActivationTimer->setProperty("index", index);
                     m_autoActivationTimer->start();
                 }
             }
         } else {
             m_autoActivationTimer->stop();
             if (newHoveredWidget && newHoveredWidget->isHovered()) {
                 newHoveredWidget->setHovered(false);
                 emit itemUnhovered(index);
             }
         }
     } else {
         m_view->hideDropIndicator();
     }
 
     return false;
 }
 
 bool KItemListController::dropEvent(QGraphicsSceneDragDropEvent* event, const QTransform& transform)
 {
     if (!m_view) {
         return false;
     }
 
     m_autoActivationTimer->stop();
     m_view->setAutoScroll(false);
 
     const QPointF pos = transform.map(event->pos());
 
     int dropAboveIndex = -1;
     if (m_model->sortRole().isEmpty()) {
         // The model supports inserting of items between other items.
         dropAboveIndex = m_view->showDropIndicator(pos);
     }
 
     if (dropAboveIndex >= 0) {
         // Something has been dropped between two items.
         m_view->hideDropIndicator();
         emit aboveItemDropEvent(dropAboveIndex, event);
     } else if (!event->mimeData()->hasFormat(m_model->blacklistItemDropEventMimeType())) {
         // Something has been dropped on an item or on an empty part of the view.
         emit itemDropEvent(m_view->itemAt(pos), event);
     }
 
     QAccessibleEvent accessibilityEvent(view(), QAccessible::DragDropEnd);
     QAccessible::updateAccessibility(&accessibilityEvent);
 
     return true;
 }
 
 bool KItemListController::hoverEnterEvent(QGraphicsSceneHoverEvent* event, const QTransform& transform)
 {
     Q_UNUSED(event);
     Q_UNUSED(transform);
     return false;
 }
 
 bool KItemListController::hoverMoveEvent(QGraphicsSceneHoverEvent* event, const QTransform& transform)
 {
     Q_UNUSED(transform);
     if (!m_model || !m_view) {
         return false;
     }
 
     KItemListWidget* oldHoveredWidget = hoveredWidget();
     const QPointF pos = transform.map(event->pos());
     KItemListWidget* newHoveredWidget = widgetForPos(pos);
 
     if (oldHoveredWidget != newHoveredWidget) {
         if (oldHoveredWidget) {
             oldHoveredWidget->setHovered(false);
             emit itemUnhovered(oldHoveredWidget->index());
         }
 
         if (newHoveredWidget) {
             newHoveredWidget->setHovered(true);
             const QPointF mappedPos = newHoveredWidget->mapFromItem(m_view, pos);
             newHoveredWidget->setHoverPosition(mappedPos);
             emit itemHovered(newHoveredWidget->index());
         }
     } else if (oldHoveredWidget) {
         const QPointF mappedPos = oldHoveredWidget->mapFromItem(m_view, pos);
         oldHoveredWidget->setHoverPosition(mappedPos);
     }
 
     return false;
 }
 
 bool KItemListController::hoverLeaveEvent(QGraphicsSceneHoverEvent* event, const QTransform& transform)
 {
     Q_UNUSED(event);
     Q_UNUSED(transform);
 
     if (!m_model || !m_view) {
         return false;
     }
 
     foreach (KItemListWidget* widget, m_view->visibleItemListWidgets()) {
         if (widget->isHovered()) {
             widget->setHovered(false);
             emit itemUnhovered(widget->index());
         }
     }
     return false;
 }
 
 bool KItemListController::wheelEvent(QGraphicsSceneWheelEvent* event, const QTransform& transform)
 {
     Q_UNUSED(event);
     Q_UNUSED(transform);
     return false;
 }
 
 bool KItemListController::resizeEvent(QGraphicsSceneResizeEvent* event, const QTransform& transform)
 {
     Q_UNUSED(event);
     Q_UNUSED(transform);
     return false;
 }
 
 bool KItemListController::processEvent(QEvent* event, const QTransform& transform)
 {
     if (!event) {
         return false;
     }
 
     switch (event->type()) {
     case QEvent::KeyPress:
         return keyPressEvent(static_cast<QKeyEvent*>(event));
     case QEvent::InputMethod:
         return inputMethodEvent(static_cast<QInputMethodEvent*>(event));
     case QEvent::GraphicsSceneMousePress:
         return mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(event), QTransform());
     case QEvent::GraphicsSceneMouseMove:
         return mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(event), QTransform());
     case QEvent::GraphicsSceneMouseRelease:
         return mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(event), QTransform());
     case QEvent::GraphicsSceneMouseDoubleClick:
         return mouseDoubleClickEvent(static_cast<QGraphicsSceneMouseEvent*>(event), QTransform());
     case QEvent::GraphicsSceneWheel:
          return wheelEvent(static_cast<QGraphicsSceneWheelEvent*>(event), QTransform());
     case QEvent::GraphicsSceneDragEnter:
         return dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent*>(event), QTransform());
     case QEvent::GraphicsSceneDragLeave:
         return dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event), QTransform());
     case QEvent::GraphicsSceneDragMove:
         return dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event), QTransform());
     case QEvent::GraphicsSceneDrop:
         return dropEvent(static_cast<QGraphicsSceneDragDropEvent*>(event), QTransform());
     case QEvent::GraphicsSceneHoverEnter:
         return hoverEnterEvent(static_cast<QGraphicsSceneHoverEvent*>(event), QTransform());
     case QEvent::GraphicsSceneHoverMove:
         return hoverMoveEvent(static_cast<QGraphicsSceneHoverEvent*>(event), QTransform());
     case QEvent::GraphicsSceneHoverLeave:
         return hoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent*>(event), QTransform());
     case QEvent::GraphicsSceneResize:
         return resizeEvent(static_cast<QGraphicsSceneResizeEvent*>(event), transform);
     default:
         break;
     }
 
     return false;
 }
 
 void KItemListController::slotViewScrollOffsetChanged(qreal current, qreal previous)
 {
     if (!m_view) {
         return;
     }
 
     KItemListRubberBand* rubberBand = m_view->rubberBand();
     if (rubberBand->isActive()) {
         const qreal diff = current - previous;
         // TODO: Ideally just QCursor::pos() should be used as
         // new end-position but it seems there is no easy way
         // to have something like QWidget::mapFromGlobal() for QGraphicsWidget
         // (... or I just missed an easy way to do the mapping)
         QPointF endPos = rubberBand->endPosition();
         if (m_view->scrollOrientation() == Qt::Vertical) {
             endPos.ry() += diff;
         } else {
             endPos.rx() += diff;
         }
 
         rubberBand->setEndPosition(endPos);
     }
 }
 
 void KItemListController::slotRubberBandChanged()
 {
     if (!m_view || !m_model || m_model->count() <= 0) {
         return;
     }
 
     const KItemListRubberBand* rubberBand = m_view->rubberBand();
     const QPointF startPos = rubberBand->startPosition();
     const QPointF endPos = rubberBand->endPosition();
     QRectF rubberBandRect = QRectF(startPos, endPos).normalized();
 
     const bool scrollVertical = (m_view->scrollOrientation() == Qt::Vertical);
     if (scrollVertical) {
         rubberBandRect.translate(0, -m_view->scrollOffset());
     } else {
         rubberBandRect.translate(-m_view->scrollOffset(), 0);
     }
 
     if (!m_oldSelection.isEmpty()) {
         // Clear the old selection that was available before the rubberband has
         // been activated in case if no Shift- or Control-key are pressed
         const bool shiftOrControlPressed = QApplication::keyboardModifiers() & Qt::ShiftModifier ||
                                            QApplication::keyboardModifiers() & Qt::ControlModifier;
         if (!shiftOrControlPressed) {
             m_oldSelection.clear();
         }
     }
 
     KItemSet selectedItems;
 
     // Select all visible items that intersect with the rubberband
     foreach (const KItemListWidget* widget, m_view->visibleItemListWidgets()) {
         const int index = widget->index();
 
         const QRectF widgetRect = m_view->itemRect(index);
         if (widgetRect.intersects(rubberBandRect)) {
             const QRectF iconRect = widget->iconRect().translated(widgetRect.topLeft());
             const QRectF textRect = widget->textRect().translated(widgetRect.topLeft());
             if (iconRect.intersects(rubberBandRect) || textRect.intersects(rubberBandRect)) {
                 selectedItems.insert(index);
             }
         }
     }
 
     // Select all invisible items that intersect with the rubberband. Instead of
     // iterating all items only the area which might be touched by the rubberband
     // will be checked.
     const bool increaseIndex = scrollVertical ?
                                startPos.y() > endPos.y(): startPos.x() > endPos.x();
 
     int index = increaseIndex ? m_view->lastVisibleIndex() + 1 : m_view->firstVisibleIndex() - 1;
     bool selectionFinished = false;
     do {
         const QRectF widgetRect = m_view->itemRect(index);
         if (widgetRect.intersects(rubberBandRect)) {
             selectedItems.insert(index);
         }
 
         if (increaseIndex) {
             ++index;
             selectionFinished = (index >= m_model->count()) ||
                                 ( scrollVertical && widgetRect.top()  > rubberBandRect.bottom()) ||
                                 (!scrollVertical && widgetRect.left() > rubberBandRect.right());
         } else {
             --index;
             selectionFinished = (index < 0) ||
                                 ( scrollVertical && widgetRect.bottom() < rubberBandRect.top()) ||
                                 (!scrollVertical && widgetRect.right()  < rubberBandRect.left());
         }
     } while (!selectionFinished);
 
     if (QApplication::keyboardModifiers() & Qt::ControlModifier) {
         // If Control is pressed, the selection state of all items in the rubberband is toggled.
         // Therefore, the new selection contains:
         // 1. All previously selected items which are not inside the rubberband, and
         // 2. all items inside the rubberband which have not been selected previously.
         m_selectionManager->setSelectedItems(m_oldSelection ^ selectedItems);
     }
     else {
         m_selectionManager->setSelectedItems(selectedItems + m_oldSelection);
     }
 }
 
 void KItemListController::startDragging()
 {
     if (!m_view || !m_model) {
         return;
     }
 
     const KItemSet selectedItems = m_selectionManager->selectedItems();
     if (selectedItems.isEmpty()) {
         return;
     }
 
     QMimeData* data = m_model->createMimeData(selectedItems);
     if (!data) {
         return;
     }
 
     // The created drag object will be owned and deleted
     // by QApplication::activeWindow().
     QDrag* drag = new QDrag(QApplication::activeWindow());
     drag->setMimeData(data);
 
     const QPixmap pixmap = m_view->createDragPixmap(selectedItems);
     drag->setPixmap(pixmap);
 
     const QPoint hotSpot((pixmap.width() / pixmap.devicePixelRatio()) / 2, 0);
     drag->setHotSpot(hotSpot);
 
     drag->exec(Qt::MoveAction | Qt::CopyAction | Qt::LinkAction, Qt::CopyAction);
 
     QAccessibleEvent accessibilityEvent(view(), QAccessible::DragDropStart);
     QAccessible::updateAccessibility(&accessibilityEvent);
 }
 
 KItemListWidget* KItemListController::hoveredWidget() const
 {
     Q_ASSERT(m_view);
 
     foreach (KItemListWidget* widget, m_view->visibleItemListWidgets()) {
         if (widget->isHovered()) {
             return widget;
         }
     }
 
     return 0;
 }
 
 KItemListWidget* KItemListController::widgetForPos(const QPointF& pos) const
 {
     Q_ASSERT(m_view);
 
     foreach (KItemListWidget* widget, m_view->visibleItemListWidgets()) {
         const QPointF mappedPos = widget->mapFromItem(m_view, pos);
 
         const bool hovered = widget->contains(mappedPos) &&
                              !widget->expansionToggleRect().contains(mappedPos);
         if (hovered) {
             return widget;
         }
     }
 
     return 0;
 }
 
 void KItemListController::updateKeyboardAnchor()
 {
     const bool validAnchor = m_keyboardAnchorIndex >= 0 &&
                              m_keyboardAnchorIndex < m_model->count() &&
                              keyboardAnchorPos(m_keyboardAnchorIndex) == m_keyboardAnchorPos;
     if (!validAnchor) {
         const int index = m_selectionManager->currentItem();
         m_keyboardAnchorIndex = index;
         m_keyboardAnchorPos = keyboardAnchorPos(index);
     }
 }
 
 int KItemListController::nextRowIndex(int index) const
 {
     if (m_keyboardAnchorIndex < 0) {
         return index;
     }
 
     const int maxIndex = m_model->count() - 1;
     if (index == maxIndex) {
         return index;
     }
 
     // Calculate the index of the last column inside the row of the current index
     int lastColumnIndex = index;
     while (keyboardAnchorPos(lastColumnIndex + 1) > keyboardAnchorPos(lastColumnIndex)) {
         ++lastColumnIndex;
         if (lastColumnIndex >= maxIndex) {
             return index;
         }
     }
 
     // Based on the last column index go to the next row and calculate the nearest index
     // that is below the current index
     int nextRowIndex = lastColumnIndex + 1;
     int searchIndex = nextRowIndex;
     qreal minDiff = qAbs(m_keyboardAnchorPos - keyboardAnchorPos(nextRowIndex));
     while (searchIndex < maxIndex && keyboardAnchorPos(searchIndex + 1) > keyboardAnchorPos(searchIndex)) {
         ++searchIndex;
         const qreal searchDiff = qAbs(m_keyboardAnchorPos - keyboardAnchorPos(searchIndex));
         if (searchDiff < minDiff) {
             minDiff = searchDiff;
             nextRowIndex = searchIndex;
         }
     }
 
     return nextRowIndex;
 }
 
 int KItemListController::previousRowIndex(int index) const
 {
     if (m_keyboardAnchorIndex < 0 || index == 0) {
         return index;
     }
 
     // Calculate the index of the first column inside the row of the current index
     int firstColumnIndex = index;
     while (keyboardAnchorPos(firstColumnIndex - 1) < keyboardAnchorPos(firstColumnIndex)) {
         --firstColumnIndex;
         if (firstColumnIndex <= 0) {
             return index;
         }
     }
 
     // Based on the first column index go to the previous row and calculate the nearest index
     // that is above the current index
     int previousRowIndex = firstColumnIndex - 1;
     int searchIndex = previousRowIndex;
     qreal minDiff = qAbs(m_keyboardAnchorPos - keyboardAnchorPos(previousRowIndex));
     while (searchIndex > 0 && keyboardAnchorPos(searchIndex - 1) < keyboardAnchorPos(searchIndex)) {
         --searchIndex;
         const qreal searchDiff = qAbs(m_keyboardAnchorPos - keyboardAnchorPos(searchIndex));
         if (searchDiff < minDiff) {
             minDiff = searchDiff;
             previousRowIndex = searchIndex;
         }
     }
 
     return previousRowIndex;
 }
 
 qreal KItemListController::keyboardAnchorPos(int index) const
 {
     const QRectF itemRect = m_view->itemRect(index);
     if (!itemRect.isEmpty()) {
         return (m_view->scrollOrientation() == Qt::Vertical) ? itemRect.x() : itemRect.y();
     }
 
     return 0;
 }
 
 void KItemListController::updateExtendedSelectionRegion()
 {
     if (m_view) {
         const bool extend = (m_selectionBehavior != MultiSelection);
         KItemListStyleOption option = m_view->styleOption();
         if (option.extendedSelectionRegion != extend) {
             option.extendedSelectionRegion = extend;
             m_view->setStyleOption(option);
         }
     }
 }
 
diff --git a/src/kitemviews/kitemlistcontroller.h b/src/kitemviews/kitemlistcontroller.h
index 5e5e6b7c3..f29377443 100644
--- a/src/kitemviews/kitemlistcontroller.h
+++ b/src/kitemviews/kitemlistcontroller.h
@@ -1,350 +1,352 @@
 /***************************************************************************
  *   Copyright (C) 2011 by Peter Penz <peter.penz19@gmail.com>             *
  *                                                                         *
  *   Based on the Itemviews NG project from Trolltech Labs:                *
  *   http://qt.gitorious.org/qt-labs/itemviews-ng                          *
  *                                                                         *
  *   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 KITEMLISTCONTROLLER_H
 #define KITEMLISTCONTROLLER_H
 
 #include "dolphin_export.h"
 
 #include "kitemset.h"
 
 #include <QObject>
 #include <QPointF>
 class QTimer;
 class KItemModelBase;
 class KItemListKeyboardSearchManager;
 class KItemListSelectionManager;
 class KItemListView;
 class KItemListWidget;
 class QGraphicsSceneHoverEvent;
 class QGraphicsSceneDragDropEvent;
 class QGraphicsSceneMouseEvent;
 class QGraphicsSceneResizeEvent;
 class QGraphicsSceneWheelEvent;
 class QHideEvent;
 class QInputMethodEvent;
 class QKeyEvent;
 class QShowEvent;
 class QTransform;
 
 /**
  * @brief Controls the view, model and selection of an item-list.
  *
  * For a working item-list it is mandatory to set a compatible view and model
  * with KItemListController::setView() and KItemListController::setModel().
  *
  * @see KItemListView
  * @see KItemModelBase
  * @see KItemListSelectionManager
  */
 class DOLPHIN_EXPORT KItemListController : public QObject
 {
     Q_OBJECT
     Q_PROPERTY(KItemModelBase* model READ model WRITE setModel)
     Q_PROPERTY(KItemListView *view READ view WRITE setView)
     Q_PROPERTY(SelectionBehavior selectionBehavior READ selectionBehavior WRITE setSelectionBehavior)
     Q_PROPERTY(AutoActivationBehavior autoActivationBehavior READ autoActivationBehavior WRITE setAutoActivationBehavior)
     Q_PROPERTY(MouseDoubleClickAction mouseDoubleClickAction READ mouseDoubleClickAction WRITE setMouseDoubleClickAction)
 
 public:
     enum SelectionBehavior {
         NoSelection,
         SingleSelection,
         MultiSelection
     };
     Q_ENUM(SelectionBehavior)
 
     enum AutoActivationBehavior {
         ActivationAndExpansion,
         ExpansionOnly
     };
 
     enum MouseDoubleClickAction {
         ActivateAndExpandItem,
         ActivateItemOnly
     };
 
     /**
      * @param model  Model of the controller. The ownership is passed to the controller.
      * @param view   View of the controller. The ownership is passed to the controller.
      * @param parent Optional parent object.
      */
     KItemListController(KItemModelBase* model, KItemListView* view, QObject* parent = 0);
     virtual ~KItemListController();
 
     void setModel(KItemModelBase* model);
     KItemModelBase* model() const;
 
     void setView(KItemListView* view);
     KItemListView* view() const;
 
     KItemListSelectionManager* selectionManager() const;
 
     void setSelectionBehavior(SelectionBehavior behavior);
     SelectionBehavior selectionBehavior() const;
 
     void setAutoActivationBehavior(AutoActivationBehavior behavior);
     AutoActivationBehavior autoActivationBehavior() const;
 
     void setMouseDoubleClickAction(MouseDoubleClickAction action);
     MouseDoubleClickAction mouseDoubleClickAction() const;
 
     /**
      * Sets the delay in milliseconds when dragging an object above an item
      * until the item gets activated automatically. A value of -1 indicates
      * that no automatic activation will be done at all (= default value).
      *
      * The hovered item must support dropping (see KItemModelBase::supportsDropping()),
      * otherwise the automatic activation is not available.
      *
      * After activating the item the signal itemActivated() will be
      * emitted. If the view supports the expanding of items
      * (KItemListView::supportsItemExpanding() returns true) and the item
      * itself is expandable (see KItemModelBase::isExpandable()) then instead
      * of activating the item it gets expanded instead (see
      * KItemModelBase::setExpanded()).
      */
     void setAutoActivationDelay(int delay);
     int autoActivationDelay() const;
 
     /**
      * If set to true, the signals itemActivated() and itemsActivated() are emitted
      * after a single-click of the left mouse button. If set to false (the default),
      * the setting from style()->styleHint(QStyle::SH_ItemView_ActivateItemOnSingleClick) is used.
      */
     void setSingleClickActivationEnforced(bool singleClick);
     bool singleClickActivationEnforced() const;
 
     virtual bool showEvent(QShowEvent* event);
     virtual bool hideEvent(QHideEvent* event);
     virtual bool keyPressEvent(QKeyEvent* event);
     virtual bool inputMethodEvent(QInputMethodEvent* event);
     virtual bool mousePressEvent(QGraphicsSceneMouseEvent* event, const QTransform& transform);
     virtual bool mouseMoveEvent(QGraphicsSceneMouseEvent* event, const QTransform& transform);
     virtual bool mouseReleaseEvent(QGraphicsSceneMouseEvent* event, const QTransform& transform);
     virtual bool mouseDoubleClickEvent(QGraphicsSceneMouseEvent* event, const QTransform& transform);
     virtual bool dragEnterEvent(QGraphicsSceneDragDropEvent* event, const QTransform& transform);
     virtual bool dragLeaveEvent(QGraphicsSceneDragDropEvent* event, const QTransform& transform);
     virtual bool dragMoveEvent(QGraphicsSceneDragDropEvent* event, const QTransform& transform);
     virtual bool dropEvent(QGraphicsSceneDragDropEvent* event, const QTransform& transform);
     virtual bool hoverEnterEvent(QGraphicsSceneHoverEvent* event, const QTransform& transform);
     virtual bool hoverMoveEvent(QGraphicsSceneHoverEvent* event, const QTransform& transform);
     virtual bool hoverLeaveEvent(QGraphicsSceneHoverEvent* event, const QTransform& transform);
     virtual bool wheelEvent(QGraphicsSceneWheelEvent* event, const QTransform& transform);
     virtual bool resizeEvent(QGraphicsSceneResizeEvent* event, const QTransform& transform);
     virtual bool processEvent(QEvent* event, const QTransform& transform);
 
 signals:
     /**
      * Is emitted if exactly one item has been activated by e.g. a mouse-click
      * or by pressing Return/Enter.
      */
     void itemActivated(int index);
 
     /**
      * Is emitted if more than one item has been activated by pressing Return/Enter
      * when having a selection.
      */
     void itemsActivated(const KItemSet& indexes);
 
     void itemMiddleClicked(int index);
 
     /**
      * Emitted if a context-menu is requested for the item with
      * the index \a index. It is assured that the index is valid.
      */
     void itemContextMenuRequested(int index, const QPointF& pos);
 
     /**
      * Emitted if a context-menu is requested for the KItemListView.
      */
     void viewContextMenuRequested(const QPointF& pos);
 
     /**
      * Emitted if a context-menu is requested for the header of the KItemListView.
      */
     void headerContextMenuRequested(const QPointF& pos);
 
     /**
      * Is emitted if the item with the index \p index gets hovered.
      */
     void itemHovered(int index);
 
     /**
      * Is emitted if the item with the index \p index gets unhovered.
      * It is assured that the signal itemHovered() for this index
      * has been emitted before.
      */
     void itemUnhovered(int index);
 
     /**
      * Is emitted if a mouse-button has been pressed above an item.
      * If the index is smaller than 0, the mouse-button has been pressed
      * above the viewport.
      */
     void mouseButtonPressed(int itemIndex, Qt::MouseButtons buttons);
 
     /**
      * Is emitted if a mouse-button has been released above an item.
      * It is assured that the signal mouseButtonPressed() has been emitted before.
      * If the index is smaller than 0, the mouse-button has been pressed
      * above the viewport.
      */
     void mouseButtonReleased(int itemIndex, Qt::MouseButtons buttons);
 
     void itemExpansionToggleClicked(int index);
 
     /**
      * Is emitted if a drop event is done above the item with the index
      * \a index. If \a index is < 0 the drop event is done above an
      * empty area of the view.
      * TODO: Introduce a new signal viewDropEvent(QGraphicsSceneDragDropEvent),
      *       which is emitted if the drop event occurs on an empty area in
      *       the view, and make sure that index is always >= 0 in itemDropEvent().
      */
     void itemDropEvent(int index, QGraphicsSceneDragDropEvent* event);
 
     /**
      * Is emitted if a drop event is done between the item with the index
      * \a index and the previous item.
      */
     void aboveItemDropEvent(int index, QGraphicsSceneDragDropEvent* event);
 
     /**
      * Is emitted if the Escape key is pressed.
      */
     void escapePressed();
 
     void modelChanged(KItemModelBase* current, KItemModelBase* previous);
     void viewChanged(KItemListView* current, KItemListView* previous);
 
+    void selectedItemTextPressed(int index);
+
 private slots:
     void slotViewScrollOffsetChanged(qreal current, qreal previous);
 
     /**
      * Is invoked when the rubberband boundaries have been changed and will select
      * all items that are touched by the rubberband.
      */
     void slotRubberBandChanged();
 
     void slotChangeCurrentItem(const QString& text, bool searchFromNextItem);
 
     void slotAutoActivationTimeout();
 
 private:
     /**
      * Creates a QDrag object and initiates a drag-operation.
      */
     void startDragging();
 
     /**
      * @return Widget that is currently in the hovered state. 0 is returned
      *         if no widget is marked as hovered.
      */
     KItemListWidget* hoveredWidget() const;
 
     /**
      * @return Widget that is below the position \a pos. 0 is returned
      *         if no widget is below the position.
      */
     KItemListWidget* widgetForPos(const QPointF& pos) const;
 
     /**
      * Updates m_keyboardAnchorIndex and m_keyboardAnchorPos. If no anchor is
      * set, it will be adjusted to the current item. If it is set it will be
      * checked whether it is still valid, otherwise it will be reset to the
      * current item.
      */
     void updateKeyboardAnchor();
 
     /**
      * @return Index for the next row based on \a index.
      *         If there is no next row \a index will be returned.
      */
     int nextRowIndex(int index) const;
 
     /**
      * @return Index for the previous row based on  \a index.
      *         If there is no previous row \a index will be returned.
      */
     int previousRowIndex(int index) const;
 
     /**
      * Helper method for updateKeyboardAnchor(), previousRowIndex() and nextRowIndex().
      * @return The position of the keyboard anchor for the item with the index \a index.
      *         If a horizontal scrolling is used the y-position of the item will be returned,
      *         for the vertical scrolling the x-position will be returned.
      */
     qreal keyboardAnchorPos(int index) const;
 
     /**
      * Dependent on the selection-behavior the extendedSelectionRegion-property
      * of the KItemListStyleOption from the view should be adjusted: If no
      * rubberband selection is used the property should be enabled.
      */
     void updateExtendedSelectionRegion();
 
 private:
     bool m_singleClickActivationEnforced;
     bool m_selectionTogglePressed;
     bool m_clearSelectionIfItemsAreNotDragged;
     SelectionBehavior m_selectionBehavior;
     AutoActivationBehavior m_autoActivationBehavior;
     MouseDoubleClickAction m_mouseDoubleClickAction;
     KItemModelBase* m_model;
     KItemListView* m_view;
     KItemListSelectionManager* m_selectionManager;
     KItemListKeyboardSearchManager* m_keyboardManager;
     int m_pressedIndex;
     QPointF m_pressedMousePos;
 
     QTimer* m_autoActivationTimer;
 
     /**
      * When starting a rubberband selection during a Shift- or Control-key has been
      * pressed the current selection should never be deleted. To be able to restore
      * the current selection it is remembered in m_oldSelection before the
      * rubberband gets activated.
      */
     KItemSet m_oldSelection;
 
     /**
      * Assuming a view is given with a vertical scroll-orientation, grouped items and
      * a maximum of 4 columns:
      *
      *  1  2  3  4
      *  5  6  7
      *  8  9 10 11
      * 12 13 14
      *
      * If the current index is on 4 and key-down is pressed, then item 7 gets the current
      * item. Now when pressing key-down again item 11 should get the current item and not
      * item 10. This makes it necessary to keep track of the requested column to have a
      * similar behavior like in a text editor:
      */
     int m_keyboardAnchorIndex;
     qreal m_keyboardAnchorPos;
 };
 
 #endif
 
 
diff --git a/src/kitemviews/kitemlistview.cpp b/src/kitemviews/kitemlistview.cpp
index d840509da..660bffe57 100644
--- a/src/kitemviews/kitemlistview.cpp
+++ b/src/kitemviews/kitemlistview.cpp
@@ -1,2732 +1,2745 @@
 /***************************************************************************
  *   Copyright (C) 2011 by Peter Penz <peter.penz19@gmail.com>             *
  *                                                                         *
  *   Based on the Itemviews NG project from Trolltech Labs:                *
  *   http://qt.gitorious.org/qt-labs/itemviews-ng                          *
  *                                                                         *
  *   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 "kitemlistview.h"
 
 #include "dolphindebug.h"
 #include "kitemlistcontainer.h"
 #include "kitemlistcontroller.h"
 #include "kitemlistheader.h"
 #include "kitemlistselectionmanager.h"
 #include "kitemlistwidget.h"
 
 #include "private/kitemlistheaderwidget.h"
 #include "private/kitemlistrubberband.h"
 #include "private/kitemlistsizehintresolver.h"
 #include "private/kitemlistviewlayouter.h"
 #include "private/kitemlistviewanimation.h"
 
 #include <QGraphicsSceneMouseEvent>
 #include <QGraphicsView>
 #include <QPainter>
 #include <QStyle>
 #include <QStyleOptionRubberBand>
 #include <QTimer>
 #include <QElapsedTimer>
 
 #include <algorithm>
 
 #include "kitemlistviewaccessible.h"
 
 namespace {
     // Time in ms until reaching the autoscroll margin triggers
     // an initial autoscrolling
     const int InitialAutoScrollDelay = 700;
 
     // Delay in ms for triggering the next autoscroll
     const int RepeatingAutoScrollDelay = 1000 / 60;
 }
 
 #ifndef QT_NO_ACCESSIBILITY
 QAccessibleInterface* accessibleInterfaceFactory(const QString& key, QObject* object)
 {
     Q_UNUSED(key)
 
     if (KItemListContainer* container = qobject_cast<KItemListContainer*>(object)) {
         return new KItemListContainerAccessible(container);
     } else if (KItemListView* view = qobject_cast<KItemListView*>(object)) {
         return new KItemListViewAccessible(view);
     }
 
     return 0;
 }
 #endif
 
 KItemListView::KItemListView(QGraphicsWidget* parent) :
     QGraphicsWidget(parent),
     m_enabledSelectionToggles(false),
     m_grouped(false),
     m_supportsItemExpanding(false),
     m_editingRole(false),
     m_activeTransactions(0),
     m_endTransactionAnimationHint(Animation),
     m_itemSize(),
     m_controller(0),
     m_model(0),
     m_visibleRoles(),
     m_widgetCreator(0),
     m_groupHeaderCreator(0),
     m_styleOption(),
     m_visibleItems(),
     m_visibleGroups(),
     m_visibleCells(),
     m_sizeHintResolver(0),
     m_layouter(0),
     m_animation(0),
     m_layoutTimer(0),
     m_oldScrollOffset(0),
     m_oldMaximumScrollOffset(0),
     m_oldItemOffset(0),
     m_oldMaximumItemOffset(0),
     m_skipAutoScrollForRubberBand(false),
     m_rubberBand(0),
     m_mousePos(),
     m_autoScrollIncrement(0),
     m_autoScrollTimer(0),
     m_header(0),
     m_headerWidget(0),
     m_dropIndicator()
 {
     setAcceptHoverEvents(true);
 
     m_sizeHintResolver = new KItemListSizeHintResolver(this);
 
     m_layouter = new KItemListViewLayouter(m_sizeHintResolver, this);
 
     m_animation = new KItemListViewAnimation(this);
     connect(m_animation, &KItemListViewAnimation::finished,
             this, &KItemListView::slotAnimationFinished);
 
     m_layoutTimer = new QTimer(this);
     m_layoutTimer->setInterval(300);
     m_layoutTimer->setSingleShot(true);
     connect(m_layoutTimer, &QTimer::timeout, this, &KItemListView::slotLayoutTimerFinished);
 
     m_rubberBand = new KItemListRubberBand(this);
     connect(m_rubberBand, &KItemListRubberBand::activationChanged, this, &KItemListView::slotRubberBandActivationChanged);
 
     m_headerWidget = new KItemListHeaderWidget(this);
     m_headerWidget->setVisible(false);
 
     m_header = new KItemListHeader(this);
 
 #ifndef QT_NO_ACCESSIBILITY
     QAccessible::installFactory(accessibleInterfaceFactory);
 #endif
 
 }
 
 KItemListView::~KItemListView()
 {
     // The group headers are children of the widgets created by
     // widgetCreator(). So it is mandatory to delete the group headers
     // first.
     delete m_groupHeaderCreator;
     m_groupHeaderCreator = 0;
 
     delete m_widgetCreator;
     m_widgetCreator = 0;
 
     delete m_sizeHintResolver;
     m_sizeHintResolver = 0;
 }
 
 void KItemListView::setScrollOffset(qreal offset)
 {
     if (offset < 0) {
         offset = 0;
     }
 
     const qreal previousOffset = m_layouter->scrollOffset();
     if (offset == previousOffset) {
         return;
     }
 
     m_layouter->setScrollOffset(offset);
     m_animation->setScrollOffset(offset);
 
     // Don't check whether the m_layoutTimer is active: Changing the
     // scroll offset must always trigger a synchronous layout, otherwise
     // the smooth-scrolling might get jerky.
     doLayout(NoAnimation);
     onScrollOffsetChanged(offset, previousOffset);
 }
 
 qreal KItemListView::scrollOffset() const
 {
     return m_layouter->scrollOffset();
 }
 
 qreal KItemListView::maximumScrollOffset() const
 {
     return m_layouter->maximumScrollOffset();
 }
 
 void KItemListView::setItemOffset(qreal offset)
 {
     if (m_layouter->itemOffset() == offset) {
         return;
     }
 
     m_layouter->setItemOffset(offset);
     if (m_headerWidget->isVisible()) {
         m_headerWidget->setOffset(offset);
     }
 
     // Don't check whether the m_layoutTimer is active: Changing the
     // item offset must always trigger a synchronous layout, otherwise
     // the smooth-scrolling might get jerky.
     doLayout(NoAnimation);
 }
 
 qreal KItemListView::itemOffset() const
 {
     return m_layouter->itemOffset();
 }
 
 qreal KItemListView::maximumItemOffset() const
 {
     return m_layouter->maximumItemOffset();
 }
 
 int KItemListView::maximumVisibleItems() const
 {
     return m_layouter->maximumVisibleItems();
 }
 
 void KItemListView::setVisibleRoles(const QList<QByteArray>& roles)
 {
     const QList<QByteArray> previousRoles = m_visibleRoles;
     m_visibleRoles = roles;
     onVisibleRolesChanged(roles, previousRoles);
 
     m_sizeHintResolver->clearCache();
     m_layouter->markAsDirty();
 
     if (m_itemSize.isEmpty()) {
         m_headerWidget->setColumns(roles);
         updatePreferredColumnWidths();
         if (!m_headerWidget->automaticColumnResizing()) {
             // The column-width of new roles are still 0. Apply the preferred
             // column-width as default with.
             foreach (const QByteArray& role, m_visibleRoles) {
                 if (m_headerWidget->columnWidth(role) == 0) {
                     const qreal width = m_headerWidget->preferredColumnWidth(role);
                     m_headerWidget->setColumnWidth(role, width);
                 }
             }
 
             applyColumnWidthsFromHeader();
         }
     }
 
     const bool alternateBackgroundsChanged = m_itemSize.isEmpty() &&
                                              ((roles.count() > 1 && previousRoles.count() <= 1) ||
                                               (roles.count() <= 1 && previousRoles.count() > 1));
 
     QHashIterator<int, KItemListWidget*> it(m_visibleItems);
     while (it.hasNext()) {
         it.next();
         KItemListWidget* widget = it.value();
         widget->setVisibleRoles(roles);
         if (alternateBackgroundsChanged) {
             updateAlternateBackgroundForWidget(widget);
         }
     }
 
     doLayout(NoAnimation);
 }
 
 QList<QByteArray> KItemListView::visibleRoles() const
 {
     return m_visibleRoles;
 }
 
 void KItemListView::setAutoScroll(bool enabled)
 {
     if (enabled && !m_autoScrollTimer) {
         m_autoScrollTimer = new QTimer(this);
         m_autoScrollTimer->setSingleShot(true);
         connect(m_autoScrollTimer, &QTimer::timeout, this, &KItemListView::triggerAutoScrolling);
         m_autoScrollTimer->start(InitialAutoScrollDelay);
     } else if (!enabled && m_autoScrollTimer) {
         delete m_autoScrollTimer;
         m_autoScrollTimer = 0;
     }
 }
 
 bool KItemListView::autoScroll() const
 {
     return m_autoScrollTimer != 0;
 }
 
 void KItemListView::setEnabledSelectionToggles(bool enabled)
 {
     if (m_enabledSelectionToggles != enabled) {
         m_enabledSelectionToggles = enabled;
 
         QHashIterator<int, KItemListWidget*> it(m_visibleItems);
         while (it.hasNext()) {
             it.next();
             it.value()->setEnabledSelectionToggle(enabled);
         }
     }
 }
 
 bool KItemListView::enabledSelectionToggles() const
 {
     return m_enabledSelectionToggles;
 }
 
 KItemListController* KItemListView::controller() const
 {
     return m_controller;
 }
 
 KItemModelBase* KItemListView::model() const
 {
     return m_model;
 }
 
 void KItemListView::setWidgetCreator(KItemListWidgetCreatorBase* widgetCreator)
 {
     if (m_widgetCreator) {
         delete m_widgetCreator;
     }
     m_widgetCreator = widgetCreator;
 }
 
 KItemListWidgetCreatorBase* KItemListView::widgetCreator() const
 {
     if (!m_widgetCreator) {
         m_widgetCreator = defaultWidgetCreator();
     }
     return m_widgetCreator;
 }
 
 void KItemListView::setGroupHeaderCreator(KItemListGroupHeaderCreatorBase* groupHeaderCreator)
 {
     if (m_groupHeaderCreator) {
         delete m_groupHeaderCreator;
     }
     m_groupHeaderCreator = groupHeaderCreator;
 }
 
 KItemListGroupHeaderCreatorBase* KItemListView::groupHeaderCreator() const
 {
     if (!m_groupHeaderCreator) {
         m_groupHeaderCreator = defaultGroupHeaderCreator();
     }
     return m_groupHeaderCreator;
 }
 
 QSizeF KItemListView::itemSize() const
 {
     return m_itemSize;
 }
 
 QSizeF KItemListView::itemSizeHint() const
 {
     return m_sizeHintResolver->maxSizeHint();
 }
 
 const KItemListStyleOption& KItemListView::styleOption() const
 {
     return m_styleOption;
 }
 
 void KItemListView::setGeometry(const QRectF& rect)
 {
     QGraphicsWidget::setGeometry(rect);
 
     if (!m_model) {
         return;
     }
 
     const QSizeF newSize = rect.size();
     if (m_itemSize.isEmpty()) {
         m_headerWidget->resize(rect.width(), m_headerWidget->size().height());
         if (m_headerWidget->automaticColumnResizing()) {
             applyAutomaticColumnWidths();
         } else {
             const qreal requiredWidth = columnWidthsSum();
             const QSizeF dynamicItemSize(qMax(newSize.width(), requiredWidth),
                                          m_itemSize.height());
             m_layouter->setItemSize(dynamicItemSize);
         }
 
         // Triggering a synchronous layout is fine from a performance point of view,
         // as with dynamic item sizes no moving animation must be done.
         m_layouter->setSize(newSize);
         doLayout(NoAnimation);
     } else {
         const bool animate = !changesItemGridLayout(newSize,
                                                     m_layouter->itemSize(),
                                                     m_layouter->itemMargin());
         m_layouter->setSize(newSize);
 
         if (animate) {
             // Trigger an asynchronous relayout with m_layoutTimer to prevent
             // performance bottlenecks. If the timer is exceeded, an animated layout
             // will be triggered.
             if (!m_layoutTimer->isActive()) {
                 m_layoutTimer->start();
             }
         } else {
             m_layoutTimer->stop();
             doLayout(NoAnimation);
         }
     }
 }
 
 qreal KItemListView::verticalPageStep() const
 {
     qreal headerHeight = 0;
     if (m_headerWidget->isVisible()) {
         headerHeight = m_headerWidget->size().height();
     }
     return size().height() - headerHeight;
 }
 
 int KItemListView::itemAt(const QPointF& pos) const
 {
     QHashIterator<int, KItemListWidget*> it(m_visibleItems);
     while (it.hasNext()) {
         it.next();
 
         const KItemListWidget* widget = it.value();
         const QPointF mappedPos = widget->mapFromItem(this, pos);
         if (widget->contains(mappedPos)) {
             return it.key();
         }
     }
 
     return -1;
 }
 
 bool KItemListView::isAboveSelectionToggle(int index, const QPointF& pos) const
 {
     if (!m_enabledSelectionToggles) {
         return false;
     }
 
     const KItemListWidget* widget = m_visibleItems.value(index);
     if (widget) {
         const QRectF selectionToggleRect = widget->selectionToggleRect();
         if (!selectionToggleRect.isEmpty()) {
             const QPointF mappedPos = widget->mapFromItem(this, pos);
             return selectionToggleRect.contains(mappedPos);
         }
     }
     return false;
 }
 
 bool KItemListView::isAboveExpansionToggle(int index, const QPointF& pos) const
 {
     const KItemListWidget* widget = m_visibleItems.value(index);
     if (widget) {
         const QRectF expansionToggleRect = widget->expansionToggleRect();
         if (!expansionToggleRect.isEmpty()) {
             const QPointF mappedPos = widget->mapFromItem(this, pos);
             return expansionToggleRect.contains(mappedPos);
         }
     }
     return false;
 }
 
+bool KItemListView::isAboveText(int index, const QPointF &pos) const
+{
+    const KItemListWidget* widget = m_visibleItems.value(index);
+    if (widget) {
+        const QRectF &textRect = widget->textRect();
+        if (!textRect.isEmpty()) {
+            const QPointF mappedPos = widget->mapFromItem(this, pos);
+            return textRect.contains(mappedPos);
+        }
+    }
+    return false;
+}
+
 int KItemListView::firstVisibleIndex() const
 {
     return m_layouter->firstVisibleIndex();
 }
 
 int KItemListView::lastVisibleIndex() const
 {
     return m_layouter->lastVisibleIndex();
 }
 
 void KItemListView::calculateItemSizeHints(QVector<qreal>& logicalHeightHints, qreal& logicalWidthHint) const
 {
     widgetCreator()->calculateItemSizeHints(logicalHeightHints, logicalWidthHint, this);
 }
 
 void KItemListView::setSupportsItemExpanding(bool supportsExpanding)
 {
     if (m_supportsItemExpanding != supportsExpanding) {
         m_supportsItemExpanding = supportsExpanding;
         updateSiblingsInformation();
         onSupportsItemExpandingChanged(supportsExpanding);
     }
 }
 
 bool KItemListView::supportsItemExpanding() const
 {
     return m_supportsItemExpanding;
 }
 
 QRectF KItemListView::itemRect(int index) const
 {
     return m_layouter->itemRect(index);
 }
 
 QRectF KItemListView::itemContextRect(int index) const
 {
     QRectF contextRect;
 
     const KItemListWidget* widget = m_visibleItems.value(index);
     if (widget) {
         contextRect = widget->iconRect() | widget->textRect();
         contextRect.translate(itemRect(index).topLeft());
     }
 
     return contextRect;
 }
 
 void KItemListView::scrollToItem(int index)
 {
     QRectF viewGeometry = geometry();
     if (m_headerWidget->isVisible()) {
         const qreal headerHeight = m_headerWidget->size().height();
         viewGeometry.adjust(0, headerHeight, 0, 0);
     }
     QRectF currentRect = itemRect(index);
 
     // Fix for Bug 311099 - View the underscore when using Ctrl + PagDown
     currentRect.adjust(-m_styleOption.horizontalMargin, -m_styleOption.verticalMargin,
                         m_styleOption.horizontalMargin,  m_styleOption.verticalMargin);
 
     if (!viewGeometry.contains(currentRect)) {
         qreal newOffset = scrollOffset();
         if (scrollOrientation() == Qt::Vertical) {
             if (currentRect.top() < viewGeometry.top()) {
                 newOffset += currentRect.top() - viewGeometry.top();
             } else if (currentRect.bottom() > viewGeometry.bottom()) {
                 newOffset += currentRect.bottom() - viewGeometry.bottom();
             }
         } else {
             if (currentRect.left() < viewGeometry.left()) {
                 newOffset += currentRect.left() - viewGeometry.left();
             } else if (currentRect.right() > viewGeometry.right()) {
                 newOffset += currentRect.right() - viewGeometry.right();
             }
         }
 
         if (newOffset != scrollOffset()) {
             emit scrollTo(newOffset);
         }
     }
 }
 
 void KItemListView::beginTransaction()
 {
     ++m_activeTransactions;
     if (m_activeTransactions == 1) {
         onTransactionBegin();
     }
 }
 
 void KItemListView::endTransaction()
 {
     --m_activeTransactions;
     if (m_activeTransactions < 0) {
         m_activeTransactions = 0;
         qCWarning(DolphinDebug) << "Mismatch between beginTransaction()/endTransaction()";
     }
 
     if (m_activeTransactions == 0) {
         onTransactionEnd();
         doLayout(m_endTransactionAnimationHint);
         m_endTransactionAnimationHint = Animation;
     }
 }
 
 bool KItemListView::isTransactionActive() const
 {
     return m_activeTransactions > 0;
 }
 
 void KItemListView::setHeaderVisible(bool visible)
 {
     if (visible && !m_headerWidget->isVisible()) {
         QStyleOptionHeader option;
         const QSize headerSize = style()->sizeFromContents(QStyle::CT_HeaderSection,
                                                            &option, QSize());
 
         m_headerWidget->setPos(0, 0);
         m_headerWidget->resize(size().width(), headerSize.height());
         m_headerWidget->setModel(m_model);
         m_headerWidget->setColumns(m_visibleRoles);
         m_headerWidget->setZValue(1);
 
         connect(m_headerWidget, &KItemListHeaderWidget::columnWidthChanged,
                 this, &KItemListView::slotHeaderColumnWidthChanged);
         connect(m_headerWidget, &KItemListHeaderWidget::columnMoved,
                 this, &KItemListView::slotHeaderColumnMoved);
         connect(m_headerWidget, &KItemListHeaderWidget::sortOrderChanged,
                 this, &KItemListView::sortOrderChanged);
         connect(m_headerWidget, &KItemListHeaderWidget::sortRoleChanged,
                 this, &KItemListView::sortRoleChanged);
 
         m_layouter->setHeaderHeight(headerSize.height());
         m_headerWidget->setVisible(true);
     } else if (!visible && m_headerWidget->isVisible()) {
         disconnect(m_headerWidget, &KItemListHeaderWidget::columnWidthChanged,
                    this, &KItemListView::slotHeaderColumnWidthChanged);
         disconnect(m_headerWidget, &KItemListHeaderWidget::columnMoved,
                    this, &KItemListView::slotHeaderColumnMoved);
         disconnect(m_headerWidget, &KItemListHeaderWidget::sortOrderChanged,
                    this, &KItemListView::sortOrderChanged);
         disconnect(m_headerWidget, &KItemListHeaderWidget::sortRoleChanged,
                    this, &KItemListView::sortRoleChanged);
 
         m_layouter->setHeaderHeight(0);
         m_headerWidget->setVisible(false);
     }
 }
 
 bool KItemListView::isHeaderVisible() const
 {
     return m_headerWidget->isVisible();
 }
 
 KItemListHeader* KItemListView::header() const
 {
     return m_header;
 }
 
 QPixmap KItemListView::createDragPixmap(const KItemSet& indexes) const
 {
     QPixmap pixmap;
 
     if (indexes.count() == 1) {
         KItemListWidget* item = m_visibleItems.value(indexes.first());
         QGraphicsView* graphicsView = scene()->views()[0];
         if (item && graphicsView) {
             pixmap = item->createDragPixmap(0, graphicsView);
         }
     } else {
         // TODO: Not implemented yet. Probably extend the interface
         // from KItemListWidget::createDragPixmap() to return a pixmap
         // that can be used for multiple indexes.
     }
 
     return pixmap;
 }
 
 void KItemListView::editRole(int index, const QByteArray& role)
 {
     KItemListWidget* widget = m_visibleItems.value(index);
     if (!widget || m_editingRole) {
         return;
     }
 
     m_editingRole = true;
     widget->setEditedRole(role);
 
     connect(widget, &KItemListWidget::roleEditingCanceled,
             this, &KItemListView::slotRoleEditingCanceled);
     connect(widget, &KItemListWidget::roleEditingFinished,
             this, &KItemListView::slotRoleEditingFinished);
 }
 
 void KItemListView::paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget)
 {
     QGraphicsWidget::paint(painter, option, widget);
 
     if (m_rubberBand->isActive()) {
         QRectF rubberBandRect = QRectF(m_rubberBand->startPosition(),
                                        m_rubberBand->endPosition()).normalized();
 
         const QPointF topLeft = rubberBandRect.topLeft();
         if (scrollOrientation() == Qt::Vertical) {
             rubberBandRect.moveTo(topLeft.x(), topLeft.y() - scrollOffset());
         } else {
             rubberBandRect.moveTo(topLeft.x() - scrollOffset(), topLeft.y());
         }
 
         QStyleOptionRubberBand opt;
         opt.initFrom(widget);
         opt.shape = QRubberBand::Rectangle;
         opt.opaque = false;
         opt.rect = rubberBandRect.toRect();
         style()->drawControl(QStyle::CE_RubberBand, &opt, painter);
     }
 
     if (!m_dropIndicator.isEmpty()) {
         const QRectF r = m_dropIndicator.toRect();
 
         QColor color = palette().brush(QPalette::Normal, QPalette::Highlight).color();
         painter->setPen(color);
 
         // TODO: The following implementation works only for a vertical scroll-orientation
         // and assumes a height of the m_draggingInsertIndicator of 1.
         Q_ASSERT(r.height() == 1);
         painter->drawLine(r.left() + 1, r.top(), r.right() - 1, r.top());
 
         color.setAlpha(128);
         painter->setPen(color);
         painter->drawRect(r.left(), r.top() - 1, r.width() - 1, 2);
     }
 }
 
 QVariant KItemListView::itemChange(GraphicsItemChange change, const QVariant &value)
 {
     if (change == QGraphicsItem::ItemSceneHasChanged && scene()) {
         if (!scene()->views().isEmpty()) {
             m_styleOption.palette = scene()->views().at(0)->palette();
         }
     }
     return QGraphicsItem::itemChange(change, value);
 }
 
 void KItemListView::setItemSize(const QSizeF& size)
 {
     const QSizeF previousSize = m_itemSize;
     if (size == previousSize) {
         return;
     }
 
     // Skip animations when the number of rows or columns
     // are changed in the grid layout. Although the animation
     // engine can handle this usecase, it looks obtrusive.
     const bool animate = !changesItemGridLayout(m_layouter->size(),
                                                 size,
                                                 m_layouter->itemMargin());
 
     const bool alternateBackgroundsChanged = (m_visibleRoles.count() > 1) &&
                                              (( m_itemSize.isEmpty() && !size.isEmpty()) ||
                                               (!m_itemSize.isEmpty() && size.isEmpty()));
 
     m_itemSize = size;
 
     if (alternateBackgroundsChanged) {
         // For an empty item size alternate backgrounds are drawn if more than
         // one role is shown. Assure that the backgrounds for visible items are
         // updated when changing the size in this context.
         updateAlternateBackgrounds();
     }
 
     if (size.isEmpty()) {
         if (m_headerWidget->automaticColumnResizing()) {
             updatePreferredColumnWidths();
         } else {
             // Only apply the changed height and respect the header widths
             // set by the user
             const qreal currentWidth = m_layouter->itemSize().width();
             const QSizeF newSize(currentWidth, size.height());
             m_layouter->setItemSize(newSize);
         }
     } else {
         m_layouter->setItemSize(size);
     }
 
     m_sizeHintResolver->clearCache();
     doLayout(animate ? Animation : NoAnimation);
     onItemSizeChanged(size, previousSize);
 }
 
 void KItemListView::setStyleOption(const KItemListStyleOption& option)
 {
     const KItemListStyleOption previousOption = m_styleOption;
     m_styleOption = option;
 
     bool animate = true;
     const QSizeF margin(option.horizontalMargin, option.verticalMargin);
     if (margin != m_layouter->itemMargin()) {
         // Skip animations when the number of rows or columns
         // are changed in the grid layout. Although the animation
         // engine can handle this usecase, it looks obtrusive.
         animate = !changesItemGridLayout(m_layouter->size(),
                                          m_layouter->itemSize(),
                                          margin);
         m_layouter->setItemMargin(margin);
     }
 
     if (m_grouped) {
         updateGroupHeaderHeight();
     }
 
     if (animate &&
         (previousOption.maxTextLines != option.maxTextLines || previousOption.maxTextWidth != option.maxTextWidth)) {
         // Animating a change of the maximum text size just results in expensive
         // temporary eliding and clipping operations and does not look good visually.
         animate = false;
     }
 
     QHashIterator<int, KItemListWidget*> it(m_visibleItems);
     while (it.hasNext()) {
         it.next();
         it.value()->setStyleOption(option);
     }
 
     m_sizeHintResolver->clearCache();
     m_layouter->markAsDirty();
     doLayout(animate ? Animation : NoAnimation);
 
     if (m_itemSize.isEmpty()) {
         updatePreferredColumnWidths();
     }
 
     onStyleOptionChanged(option, previousOption);
 }
 
 void KItemListView::setScrollOrientation(Qt::Orientation orientation)
 {
     const Qt::Orientation previousOrientation = m_layouter->scrollOrientation();
     if (orientation == previousOrientation) {
         return;
     }
 
     m_layouter->setScrollOrientation(orientation);
     m_animation->setScrollOrientation(orientation);
     m_sizeHintResolver->clearCache();
 
     if (m_grouped) {
         QMutableHashIterator<KItemListWidget*, KItemListGroupHeader*> it (m_visibleGroups);
         while (it.hasNext()) {
             it.next();
             it.value()->setScrollOrientation(orientation);
         }
         updateGroupHeaderHeight();
 
     }
 
     doLayout(NoAnimation);
 
     onScrollOrientationChanged(orientation, previousOrientation);
     emit scrollOrientationChanged(orientation, previousOrientation);
 }
 
 Qt::Orientation KItemListView::scrollOrientation() const
 {
     return m_layouter->scrollOrientation();
 }
 
 KItemListWidgetCreatorBase* KItemListView::defaultWidgetCreator() const
 {
     return 0;
 }
 
 KItemListGroupHeaderCreatorBase* KItemListView::defaultGroupHeaderCreator() const
 {
     return 0;
 }
 
 void KItemListView::initializeItemListWidget(KItemListWidget* item)
 {
     Q_UNUSED(item);
 }
 
 bool KItemListView::itemSizeHintUpdateRequired(const QSet<QByteArray>& changedRoles) const
 {
     Q_UNUSED(changedRoles);
     return true;
 }
 
 void KItemListView::onControllerChanged(KItemListController* current, KItemListController* previous)
 {
     Q_UNUSED(current);
     Q_UNUSED(previous);
 }
 
 void KItemListView::onModelChanged(KItemModelBase* current, KItemModelBase* previous)
 {
     Q_UNUSED(current);
     Q_UNUSED(previous);
 }
 
 void KItemListView::onScrollOrientationChanged(Qt::Orientation current, Qt::Orientation previous)
 {
     Q_UNUSED(current);
     Q_UNUSED(previous);
 }
 
 void KItemListView::onItemSizeChanged(const QSizeF& current, const QSizeF& previous)
 {
     Q_UNUSED(current);
     Q_UNUSED(previous);
 }
 
 void KItemListView::onScrollOffsetChanged(qreal current, qreal previous)
 {
     Q_UNUSED(current);
     Q_UNUSED(previous);
 }
 
 void KItemListView::onVisibleRolesChanged(const QList<QByteArray>& current, const QList<QByteArray>& previous)
 {
     Q_UNUSED(current);
     Q_UNUSED(previous);
 }
 
 void KItemListView::onStyleOptionChanged(const KItemListStyleOption& current, const KItemListStyleOption& previous)
 {
     Q_UNUSED(current);
     Q_UNUSED(previous);
 }
 
 void KItemListView::onSupportsItemExpandingChanged(bool supportsExpanding)
 {
     Q_UNUSED(supportsExpanding);
 }
 
 void KItemListView::onTransactionBegin()
 {
 }
 
 void KItemListView::onTransactionEnd()
 {
 }
 
 bool KItemListView::event(QEvent* event)
 {
     switch (event->type()) {
     case QEvent::PaletteChange:
         updatePalette();
         break;
 
     case QEvent::FontChange:
         updateFont();
         break;
 
     default:
         // Forward all other events to the controller and handle them there
         if (!m_editingRole && m_controller && m_controller->processEvent(event, transform())) {
             event->accept();
             return true;
         }
     }
 
     return QGraphicsWidget::event(event);
 }
 
 void KItemListView::mousePressEvent(QGraphicsSceneMouseEvent* event)
 {
     m_mousePos = transform().map(event->pos());
     event->accept();
 }
 
 void KItemListView::mouseMoveEvent(QGraphicsSceneMouseEvent* event)
 {
     QGraphicsWidget::mouseMoveEvent(event);
 
     m_mousePos = transform().map(event->pos());
     if (m_autoScrollTimer && !m_autoScrollTimer->isActive()) {
         m_autoScrollTimer->start(InitialAutoScrollDelay);
     }
 }
 
 void KItemListView::dragEnterEvent(QGraphicsSceneDragDropEvent* event)
 {
     event->setAccepted(true);
     setAutoScroll(true);
 }
 
 void KItemListView::dragMoveEvent(QGraphicsSceneDragDropEvent* event)
 {
     QGraphicsWidget::dragMoveEvent(event);
 
     m_mousePos = transform().map(event->pos());
     if (m_autoScrollTimer && !m_autoScrollTimer->isActive()) {
         m_autoScrollTimer->start(InitialAutoScrollDelay);
     }
 }
 
 void KItemListView::dragLeaveEvent(QGraphicsSceneDragDropEvent* event)
 {
     QGraphicsWidget::dragLeaveEvent(event);
     setAutoScroll(false);
 }
 
 void KItemListView::dropEvent(QGraphicsSceneDragDropEvent* event)
 {
     QGraphicsWidget::dropEvent(event);
     setAutoScroll(false);
 }
 
 QList<KItemListWidget*> KItemListView::visibleItemListWidgets() const
 {
     return m_visibleItems.values();
 }
 
 void KItemListView::updateFont()
 {
     if (scene() && !scene()->views().isEmpty()) {
         KItemListStyleOption option = styleOption();
         option.font = scene()->views().first()->font();
         option.fontMetrics = QFontMetrics(option.font);
 
         setStyleOption(option);
     }
 }
 
 void KItemListView::updatePalette()
 {
     if (scene() && !scene()->views().isEmpty()) {
         KItemListStyleOption option = styleOption();
         option.palette = scene()->views().first()->palette();
 
         setStyleOption(option);
     }
 }
 
 void KItemListView::slotItemsInserted(const KItemRangeList& itemRanges)
 {
     if (m_itemSize.isEmpty()) {
         updatePreferredColumnWidths(itemRanges);
     }
 
     const bool hasMultipleRanges = (itemRanges.count() > 1);
     if (hasMultipleRanges) {
         beginTransaction();
     }
 
     m_layouter->markAsDirty();
 
     m_sizeHintResolver->itemsInserted(itemRanges);
 
     int previouslyInsertedCount = 0;
     foreach (const KItemRange& range, itemRanges) {
         // range.index is related to the model before anything has been inserted.
         // As in each loop the current item-range gets inserted the index must
         // be increased by the already previously inserted items.
         const int index = range.index + previouslyInsertedCount;
         const int count = range.count;
         if (index < 0 || count <= 0) {
             qCWarning(DolphinDebug) << "Invalid item range (index:" << index << ", count:" << count << ")";
             continue;
         }
         previouslyInsertedCount += count;
 
         // Determine which visible items must be moved
         QList<int> itemsToMove;
         QHashIterator<int, KItemListWidget*> it(m_visibleItems);
         while (it.hasNext()) {
             it.next();
             const int visibleItemIndex = it.key();
             if (visibleItemIndex >= index) {
                 itemsToMove.append(visibleItemIndex);
             }
         }
 
         // Update the indexes of all KItemListWidget instances that are located
         // after the inserted items. It is important to adjust the indexes in the order
         // from the highest index to the lowest index to prevent overlaps when setting the new index.
         qSort(itemsToMove);
         for (int i = itemsToMove.count() - 1; i >= 0; --i) {
             KItemListWidget* widget = m_visibleItems.value(itemsToMove[i]);
             Q_ASSERT(widget);
             const int newIndex = widget->index() + count;
             if (hasMultipleRanges) {
                 setWidgetIndex(widget, newIndex);
             } else {
                 // Try to animate the moving of the item
                 moveWidgetToIndex(widget, newIndex);
             }
         }
 
         if (m_model->count() == count && m_activeTransactions == 0) {
             // Check whether a scrollbar is required to show the inserted items. In this case
             // the size of the layouter will be decreased before calling doLayout(): This prevents
             // an unnecessary temporary animation due to the geometry change of the inserted scrollbar.
             const bool verticalScrollOrientation = (scrollOrientation() == Qt::Vertical);
             const bool decreaseLayouterSize = ( verticalScrollOrientation && maximumScrollOffset() > size().height()) ||
                                               (!verticalScrollOrientation && maximumScrollOffset() > size().width());
             if (decreaseLayouterSize) {
                 const int scrollBarExtent = style()->pixelMetric(QStyle::PM_ScrollBarExtent);
 
                 int scrollbarSpacing = 0;
                 if (style()->styleHint(QStyle::SH_ScrollView_FrameOnlyAroundContents)) {
                     scrollbarSpacing = style()->pixelMetric(QStyle::PM_ScrollView_ScrollBarSpacing);
                 }
 
                 QSizeF layouterSize = m_layouter->size();
                 if (verticalScrollOrientation) {
                     layouterSize.rwidth() -= scrollBarExtent + scrollbarSpacing;
                 } else {
                     layouterSize.rheight() -= scrollBarExtent + scrollbarSpacing;
                 }
                 m_layouter->setSize(layouterSize);
             }
         }
 
         if (!hasMultipleRanges) {
             doLayout(animateChangedItemCount(count) ? Animation : NoAnimation, index, count);
             updateSiblingsInformation();
         }
     }
 
     if (m_controller) {
         m_controller->selectionManager()->itemsInserted(itemRanges);
     }
 
     if (hasMultipleRanges) {
         m_endTransactionAnimationHint = NoAnimation;
         endTransaction();
 
         updateSiblingsInformation();
     }
 
     if (m_grouped && (hasMultipleRanges || itemRanges.first().count < m_model->count())) {
         // In case if items of the same group have been inserted before an item that
         // currently represents the first item of the group, the group header of
         // this item must be removed.
         updateVisibleGroupHeaders();
     }
 
     if (useAlternateBackgrounds()) {
         updateAlternateBackgrounds();
     }
 }
 
 void KItemListView::slotItemsRemoved(const KItemRangeList& itemRanges)
 {
     if (m_itemSize.isEmpty()) {
         // Don't pass the item-range: The preferred column-widths of
         // all items must be adjusted when removing items.
         updatePreferredColumnWidths();
     }
 
     const bool hasMultipleRanges = (itemRanges.count() > 1);
     if (hasMultipleRanges) {
         beginTransaction();
     }
 
     m_layouter->markAsDirty();
 
     m_sizeHintResolver->itemsRemoved(itemRanges);
 
     for (int i = itemRanges.count() - 1; i >= 0; --i) {
         const KItemRange& range = itemRanges[i];
         const int index = range.index;
         const int count = range.count;
         if (index < 0 || count <= 0) {
             qCWarning(DolphinDebug) << "Invalid item range (index:" << index << ", count:" << count << ")";
             continue;
         }
 
         const int firstRemovedIndex = index;
         const int lastRemovedIndex = index + count - 1;
 
         // Remember which items have to be moved because they are behind the removed range.
         QVector<int> itemsToMove;
 
         // Remove all KItemListWidget instances that got deleted
         foreach (KItemListWidget* widget, m_visibleItems) {
             const int i = widget->index();
             if (i < firstRemovedIndex) {
                 continue;
             } else if (i > lastRemovedIndex) {
                 itemsToMove.append(i);
                 continue;
             }
 
             m_animation->stop(widget);
             // Stopping the animation might lead to recycling the widget if
             // it is invisible (see slotAnimationFinished()).
             // Check again whether it is still visible:
             if (!m_visibleItems.contains(i)) {
                 continue;
             }
 
             if (m_model->count() == 0 || hasMultipleRanges || !animateChangedItemCount(count)) {
                 // Remove the widget without animation
                 recycleWidget(widget);
             } else {
                 // Animate the removing of the items. Special case: When removing an item there
                 // is no valid model index available anymore. For the
                 // remove-animation the item gets removed from m_visibleItems but the widget
                 // will stay alive until the animation has been finished and will
                 // be recycled (deleted) in KItemListView::slotAnimationFinished().
                 m_visibleItems.remove(i);
                 widget->setIndex(-1);
                 m_animation->start(widget, KItemListViewAnimation::DeleteAnimation);
             }
         }
 
         // Update the indexes of all KItemListWidget instances that are located
         // after the deleted items. It is important to update them in ascending
         // order to prevent overlaps when setting the new index.
         std::sort(itemsToMove.begin(), itemsToMove.end());
         foreach (int i, itemsToMove) {
             KItemListWidget* widget = m_visibleItems.value(i);
             Q_ASSERT(widget);
             const int newIndex = i - count;
             if (hasMultipleRanges) {
                 setWidgetIndex(widget, newIndex);
             } else {
                 // Try to animate the moving of the item
                 moveWidgetToIndex(widget, newIndex);
             }
         }
 
         if (!hasMultipleRanges) {
             // The decrease-layout-size optimization in KItemListView::slotItemsInserted()
             // assumes an updated geometry. If items are removed during an active transaction,
             // the transaction will be temporary deactivated so that doLayout() triggers a
             // geometry update if necessary.
             const int activeTransactions = m_activeTransactions;
             m_activeTransactions = 0;
             doLayout(animateChangedItemCount(count) ? Animation : NoAnimation, index, -count);
             m_activeTransactions = activeTransactions;
             updateSiblingsInformation();
         }
     }
 
     if (m_controller) {
         m_controller->selectionManager()->itemsRemoved(itemRanges);
     }
 
     if (hasMultipleRanges) {
         m_endTransactionAnimationHint = NoAnimation;
         endTransaction();
         updateSiblingsInformation();
     }
 
     if (m_grouped && (hasMultipleRanges || m_model->count() > 0)) {
         // In case if the first item of a group has been removed, the group header
         // must be applied to the next visible item.
         updateVisibleGroupHeaders();
     }
 
     if (useAlternateBackgrounds()) {
         updateAlternateBackgrounds();
     }
 }
 
 void KItemListView::slotItemsMoved(const KItemRange& itemRange, const QList<int>& movedToIndexes)
 {
     m_sizeHintResolver->itemsMoved(itemRange, movedToIndexes);
     m_layouter->markAsDirty();
 
     if (m_controller) {
         m_controller->selectionManager()->itemsMoved(itemRange, movedToIndexes);
     }
 
     const int firstVisibleMovedIndex = qMax(firstVisibleIndex(), itemRange.index);
     const int lastVisibleMovedIndex = qMin(lastVisibleIndex(), itemRange.index + itemRange.count - 1);
 
     for (int index = firstVisibleMovedIndex; index <= lastVisibleMovedIndex; ++index) {
         KItemListWidget* widget = m_visibleItems.value(index);
         if (widget) {
             updateWidgetProperties(widget, index);
             initializeItemListWidget(widget);
         }
     }
 
     doLayout(NoAnimation);
     updateSiblingsInformation();
 }
 
 void KItemListView::slotItemsChanged(const KItemRangeList& itemRanges,
                                      const QSet<QByteArray>& roles)
 {
     const bool updateSizeHints = itemSizeHintUpdateRequired(roles);
     if (updateSizeHints && m_itemSize.isEmpty()) {
         updatePreferredColumnWidths(itemRanges);
     }
 
     foreach (const KItemRange& itemRange, itemRanges) {
         const int index = itemRange.index;
         const int count = itemRange.count;
 
         if (updateSizeHints) {
             m_sizeHintResolver->itemsChanged(index, count, roles);
             m_layouter->markAsDirty();
 
             if (!m_layoutTimer->isActive()) {
                 m_layoutTimer->start();
             }
         }
 
         // Apply the changed roles to the visible item-widgets
         const int lastIndex = index + count - 1;
         for (int i = index; i <= lastIndex; ++i) {
             KItemListWidget* widget = m_visibleItems.value(i);
             if (widget) {
                 widget->setData(m_model->data(i), roles);
             }
         }
 
         if (m_grouped && roles.contains(m_model->sortRole())) {
             // The sort-role has been changed which might result
             // in modified group headers
             updateVisibleGroupHeaders();
             doLayout(NoAnimation);
         }
 
         QAccessibleTableModelChangeEvent ev(this, QAccessibleTableModelChangeEvent::DataChanged);
         ev.setFirstRow(itemRange.index);
         ev.setLastRow(itemRange.index + itemRange.count);
         QAccessible::updateAccessibility(&ev);
     }
 }
 
 void KItemListView::slotGroupsChanged()
 {
     updateVisibleGroupHeaders();
     doLayout(NoAnimation);
     updateSiblingsInformation();
 }
 
 void KItemListView::slotGroupedSortingChanged(bool current)
 {
     m_grouped = current;
     m_layouter->markAsDirty();
 
     if (m_grouped) {
         updateGroupHeaderHeight();
     } else {
         // Clear all visible headers. Note that the QHashIterator takes a copy of
         // m_visibleGroups. Therefore, it remains valid even if items are removed
         // from m_visibleGroups in recycleGroupHeaderForWidget().
         QHashIterator<KItemListWidget*, KItemListGroupHeader*> it(m_visibleGroups);
         while (it.hasNext()) {
             it.next();
             recycleGroupHeaderForWidget(it.key());
         }
         Q_ASSERT(m_visibleGroups.isEmpty());
     }
 
     if (useAlternateBackgrounds()) {
         // Changing the group mode requires to update the alternate backgrounds
         // as with the enabled group mode the altering is done on base of the first
         // group item.
         updateAlternateBackgrounds();
     }
     updateSiblingsInformation();
     doLayout(NoAnimation);
 }
 
 void KItemListView::slotSortOrderChanged(Qt::SortOrder current, Qt::SortOrder previous)
 {
     Q_UNUSED(current);
     Q_UNUSED(previous);
     if (m_grouped) {
         updateVisibleGroupHeaders();
         doLayout(NoAnimation);
     }
 }
 
 void KItemListView::slotSortRoleChanged(const QByteArray& current, const QByteArray& previous)
 {
     Q_UNUSED(current);
     Q_UNUSED(previous);
     if (m_grouped) {
         updateVisibleGroupHeaders();
         doLayout(NoAnimation);
     }
 }
 
 void KItemListView::slotCurrentChanged(int current, int previous)
 {
     Q_UNUSED(previous);
 
     // In SingleSelection mode (e.g., in the Places Panel), the current item is
     // always the selected item. It is not necessary to highlight the current item then.
     if (m_controller->selectionBehavior() != KItemListController::SingleSelection) {
         KItemListWidget* previousWidget = m_visibleItems.value(previous, 0);
         if (previousWidget) {
             previousWidget->setCurrent(false);
         }
 
         KItemListWidget* currentWidget = m_visibleItems.value(current, 0);
         if (currentWidget) {
             currentWidget->setCurrent(true);
         }
     }
 
     QAccessibleEvent ev(this, QAccessible::Focus);
     ev.setChild(current);
     QAccessible::updateAccessibility(&ev);
 }
 
 void KItemListView::slotSelectionChanged(const KItemSet& current, const KItemSet& previous)
 {
     Q_UNUSED(previous);
 
     QHashIterator<int, KItemListWidget*> it(m_visibleItems);
     while (it.hasNext()) {
         it.next();
         const int index = it.key();
         KItemListWidget* widget = it.value();
         widget->setSelected(current.contains(index));
     }
 }
 
 void KItemListView::slotAnimationFinished(QGraphicsWidget* widget,
                                           KItemListViewAnimation::AnimationType type)
 {
     KItemListWidget* itemListWidget = qobject_cast<KItemListWidget*>(widget);
     Q_ASSERT(itemListWidget);
 
     switch (type) {
     case KItemListViewAnimation::DeleteAnimation: {
         // As we recycle the widget in this case it is important to assure that no
         // other animation has been started. This is a convention in KItemListView and
         // not a requirement defined by KItemListViewAnimation.
         Q_ASSERT(!m_animation->isStarted(itemListWidget));
 
         // All KItemListWidgets that are animated by the DeleteAnimation are not maintained
         // by m_visibleWidgets and must be deleted manually after the animation has
         // been finished.
         recycleGroupHeaderForWidget(itemListWidget);
         widgetCreator()->recycle(itemListWidget);
         break;
     }
 
     case KItemListViewAnimation::CreateAnimation:
     case KItemListViewAnimation::MovingAnimation:
     case KItemListViewAnimation::ResizeAnimation: {
         const int index = itemListWidget->index();
         const bool invisible = (index < m_layouter->firstVisibleIndex()) ||
                                (index > m_layouter->lastVisibleIndex());
         if (invisible && !m_animation->isStarted(itemListWidget)) {
             recycleWidget(itemListWidget);
         }
         break;
     }
 
     default: break;
     }
 }
 
 void KItemListView::slotLayoutTimerFinished()
 {
     m_layouter->setSize(geometry().size());
     doLayout(Animation);
 }
 
 void KItemListView::slotRubberBandPosChanged()
 {
     update();
 }
 
 void KItemListView::slotRubberBandActivationChanged(bool active)
 {
     if (active) {
         connect(m_rubberBand, &KItemListRubberBand::startPositionChanged, this, &KItemListView::slotRubberBandPosChanged);
         connect(m_rubberBand, &KItemListRubberBand::endPositionChanged, this, &KItemListView::slotRubberBandPosChanged);
         m_skipAutoScrollForRubberBand = true;
     } else {
         disconnect(m_rubberBand, &KItemListRubberBand::startPositionChanged, this, &KItemListView::slotRubberBandPosChanged);
         disconnect(m_rubberBand, &KItemListRubberBand::endPositionChanged, this, &KItemListView::slotRubberBandPosChanged);
         m_skipAutoScrollForRubberBand = false;
     }
 
     update();
 }
 
 void KItemListView::slotHeaderColumnWidthChanged(const QByteArray& role,
                                                  qreal currentWidth,
                                                  qreal previousWidth)
 {
     Q_UNUSED(role);
     Q_UNUSED(currentWidth);
     Q_UNUSED(previousWidth);
 
     m_headerWidget->setAutomaticColumnResizing(false);
     applyColumnWidthsFromHeader();
     doLayout(NoAnimation);
 }
 
 void KItemListView::slotHeaderColumnMoved(const QByteArray& role,
                                           int currentIndex,
                                           int previousIndex)
 {
     Q_ASSERT(m_visibleRoles[previousIndex] == role);
 
     const QList<QByteArray> previous = m_visibleRoles;
 
     QList<QByteArray> current = m_visibleRoles;
     current.removeAt(previousIndex);
     current.insert(currentIndex, role);
 
     setVisibleRoles(current);
 
     emit visibleRolesChanged(current, previous);
 }
 
 void KItemListView::triggerAutoScrolling()
 {
     if (!m_autoScrollTimer) {
         return;
     }
 
     int pos = 0;
     int visibleSize = 0;
     if (scrollOrientation() == Qt::Vertical) {
         pos = m_mousePos.y();
         visibleSize = size().height();
     } else {
         pos = m_mousePos.x();
         visibleSize = size().width();
     }
 
     if (m_autoScrollTimer->interval() == InitialAutoScrollDelay) {
         m_autoScrollIncrement = 0;
     }
 
     m_autoScrollIncrement = calculateAutoScrollingIncrement(pos, visibleSize, m_autoScrollIncrement);
     if (m_autoScrollIncrement == 0) {
         // The mouse position is not above an autoscroll margin (the autoscroll timer
         // will be restarted in mouseMoveEvent())
         m_autoScrollTimer->stop();
         return;
     }
 
     if (m_rubberBand->isActive() && m_skipAutoScrollForRubberBand) {
         // If a rubberband selection is ongoing the autoscrolling may only get triggered
         // if the direction of the rubberband is similar to the autoscroll direction. This
         // prevents that starting to create a rubberband within the autoscroll margins starts
         // an autoscrolling.
 
         const qreal minDiff = 4; // Ignore any autoscrolling if the rubberband is very small
         const qreal diff = (scrollOrientation() == Qt::Vertical)
                            ? m_rubberBand->endPosition().y() - m_rubberBand->startPosition().y()
                            : m_rubberBand->endPosition().x() - m_rubberBand->startPosition().x();
         if (qAbs(diff) < minDiff || (m_autoScrollIncrement < 0 && diff > 0) || (m_autoScrollIncrement > 0 && diff < 0)) {
             // The rubberband direction is different from the scroll direction (e.g. the rubberband has
             // been moved up although the autoscroll direction might be down)
             m_autoScrollTimer->stop();
             return;
         }
     }
 
     // As soon as the autoscrolling has been triggered at least once despite having an active rubberband,
     // the autoscrolling may not get skipped anymore until a new rubberband is created
     m_skipAutoScrollForRubberBand = false;
 
     const qreal maxVisibleOffset = qMax(qreal(0), maximumScrollOffset() - visibleSize);
     const qreal newScrollOffset = qMin(scrollOffset() + m_autoScrollIncrement, maxVisibleOffset);
     setScrollOffset(newScrollOffset);
 
     // Trigger the autoscroll timer which will periodically call
     // triggerAutoScrolling()
     m_autoScrollTimer->start(RepeatingAutoScrollDelay);
 }
 
 void KItemListView::slotGeometryOfGroupHeaderParentChanged()
 {
     KItemListWidget* widget = qobject_cast<KItemListWidget*>(sender());
     Q_ASSERT(widget);
     KItemListGroupHeader* groupHeader = m_visibleGroups.value(widget);
     Q_ASSERT(groupHeader);
     updateGroupHeaderLayout(widget);
 }
 
 void KItemListView::slotRoleEditingCanceled(int index, const QByteArray& role, const QVariant& value)
 {
     disconnectRoleEditingSignals(index);
 
     emit roleEditingCanceled(index, role, value);
     m_editingRole = false;
 }
 
 void KItemListView::slotRoleEditingFinished(int index, const QByteArray& role, const QVariant& value)
 {
     disconnectRoleEditingSignals(index);
 
     emit roleEditingFinished(index, role, value);
     m_editingRole = false;
 }
 
 void KItemListView::setController(KItemListController* controller)
 {
     if (m_controller != controller) {
         KItemListController* previous = m_controller;
         if (previous) {
             KItemListSelectionManager* selectionManager = previous->selectionManager();
             disconnect(selectionManager, &KItemListSelectionManager::currentChanged, this, &KItemListView::slotCurrentChanged);
             disconnect(selectionManager, &KItemListSelectionManager::selectionChanged, this, &KItemListView::slotSelectionChanged);
         }
 
         m_controller = controller;
 
         if (controller) {
             KItemListSelectionManager* selectionManager = controller->selectionManager();
             connect(selectionManager, &KItemListSelectionManager::currentChanged, this, &KItemListView::slotCurrentChanged);
             connect(selectionManager, &KItemListSelectionManager::selectionChanged, this, &KItemListView::slotSelectionChanged);
         }
 
         onControllerChanged(controller, previous);
     }
 }
 
 void KItemListView::setModel(KItemModelBase* model)
 {
     if (m_model == model) {
         return;
     }
 
     KItemModelBase* previous = m_model;
 
     if (m_model) {
         disconnect(m_model, &KItemModelBase::itemsChanged,
                    this,    &KItemListView::slotItemsChanged);
         disconnect(m_model, &KItemModelBase::itemsInserted,
                    this,    &KItemListView::slotItemsInserted);
         disconnect(m_model, &KItemModelBase::itemsRemoved,
                    this,    &KItemListView::slotItemsRemoved);
         disconnect(m_model, &KItemModelBase::itemsMoved,
                    this,    &KItemListView::slotItemsMoved);
         disconnect(m_model, &KItemModelBase::groupsChanged,
                    this,    &KItemListView::slotGroupsChanged);
         disconnect(m_model, &KItemModelBase::groupedSortingChanged,
                    this,    &KItemListView::slotGroupedSortingChanged);
         disconnect(m_model, &KItemModelBase::sortOrderChanged,
                    this,    &KItemListView::slotSortOrderChanged);
         disconnect(m_model, &KItemModelBase::sortRoleChanged,
                    this,    &KItemListView::slotSortRoleChanged);
 
         m_sizeHintResolver->itemsRemoved(KItemRangeList() << KItemRange(0, m_model->count()));
     }
 
     m_model = model;
     m_layouter->setModel(model);
     m_grouped = model->groupedSorting();
 
     if (m_model) {
         connect(m_model, &KItemModelBase::itemsChanged,
                 this,    &KItemListView::slotItemsChanged);
         connect(m_model, &KItemModelBase::itemsInserted,
                 this,    &KItemListView::slotItemsInserted);
         connect(m_model, &KItemModelBase::itemsRemoved,
                 this,    &KItemListView::slotItemsRemoved);
         connect(m_model, &KItemModelBase::itemsMoved,
                 this,    &KItemListView::slotItemsMoved);
         connect(m_model, &KItemModelBase::groupsChanged,
                 this,    &KItemListView::slotGroupsChanged);
         connect(m_model, &KItemModelBase::groupedSortingChanged,
                 this,    &KItemListView::slotGroupedSortingChanged);
         connect(m_model, &KItemModelBase::sortOrderChanged,
                 this,    &KItemListView::slotSortOrderChanged);
         connect(m_model, &KItemModelBase::sortRoleChanged,
                 this,    &KItemListView::slotSortRoleChanged);
 
         const int itemCount = m_model->count();
         if (itemCount > 0) {
             slotItemsInserted(KItemRangeList() << KItemRange(0, itemCount));
         }
     }
 
     onModelChanged(model, previous);
 }
 
 KItemListRubberBand* KItemListView::rubberBand() const
 {
     return m_rubberBand;
 }
 
 void KItemListView::doLayout(LayoutAnimationHint hint, int changedIndex, int changedCount)
 {
     if (m_layoutTimer->isActive()) {
         m_layoutTimer->stop();
     }
 
     if (m_activeTransactions > 0) {
         if (hint == NoAnimation) {
             // As soon as at least one property change should be done without animation,
             // the whole transaction will be marked as not animated.
             m_endTransactionAnimationHint = NoAnimation;
         }
         return;
     }
 
     if (!m_model || m_model->count() < 0) {
         return;
     }
 
     int firstVisibleIndex = m_layouter->firstVisibleIndex();
     if (firstVisibleIndex < 0) {
         emitOffsetChanges();
         return;
     }
 
     // Do a sanity check of the scroll-offset property: When properties of the itemlist-view have been changed
     // it might be possible that the maximum offset got changed too. Assure that the full visible range
     // is still shown if the maximum offset got decreased.
     const qreal visibleOffsetRange = (scrollOrientation() == Qt::Horizontal) ? size().width() : size().height();
     const qreal maxOffsetToShowFullRange = maximumScrollOffset() - visibleOffsetRange;
     if (scrollOffset() > maxOffsetToShowFullRange) {
         m_layouter->setScrollOffset(qMax(qreal(0), maxOffsetToShowFullRange));
         firstVisibleIndex = m_layouter->firstVisibleIndex();
     }
 
     const int lastVisibleIndex = m_layouter->lastVisibleIndex();
 
     int firstSibblingIndex = -1;
     int lastSibblingIndex = -1;
     const bool supportsExpanding = supportsItemExpanding();
 
     QList<int> reusableItems = recycleInvisibleItems(firstVisibleIndex, lastVisibleIndex, hint);
 
     // Assure that for each visible item a KItemListWidget is available. KItemListWidget
     // instances from invisible items are reused. If no reusable items are
     // found then new KItemListWidget instances get created.
     const bool animate = (hint == Animation);
     for (int i = firstVisibleIndex; i <= lastVisibleIndex; ++i) {
         bool applyNewPos = true;
         bool wasHidden = false;
 
         const QRectF itemBounds = m_layouter->itemRect(i);
         const QPointF newPos = itemBounds.topLeft();
         KItemListWidget* widget = m_visibleItems.value(i);
         if (!widget) {
             wasHidden = true;
             if (!reusableItems.isEmpty()) {
                 // Reuse a KItemListWidget instance from an invisible item
                 const int oldIndex = reusableItems.takeLast();
                 widget = m_visibleItems.value(oldIndex);
                 setWidgetIndex(widget, i);
                 updateWidgetProperties(widget, i);
                 initializeItemListWidget(widget);
             } else {
                 // No reusable KItemListWidget instance is available, create a new one
                 widget = createWidget(i);
             }
             widget->resize(itemBounds.size());
 
             if (animate && changedCount < 0) {
                 // Items have been deleted.
                 if (i >= changedIndex) {
                     // The item is located behind the removed range. Move the
                     // created item to the imaginary old position outside the
                     // view. It will get animated to the new position later.
                     const int previousIndex = i - changedCount;
                     const QRectF itemRect = m_layouter->itemRect(previousIndex);
                     if (itemRect.isEmpty()) {
                         const QPointF invisibleOldPos = (scrollOrientation() == Qt::Vertical)
                                                         ? QPointF(0, size().height()) : QPointF(size().width(), 0);
                         widget->setPos(invisibleOldPos);
                     } else {
                         widget->setPos(itemRect.topLeft());
                     }
                     applyNewPos = false;
                 }
             }
 
             if (supportsExpanding && changedCount == 0) {
                 if (firstSibblingIndex < 0) {
                     firstSibblingIndex = i;
                 }
                 lastSibblingIndex = i;
             }
         }
 
         if (animate) {
             if (m_animation->isStarted(widget, KItemListViewAnimation::MovingAnimation)) {
                 m_animation->start(widget,  KItemListViewAnimation::MovingAnimation, newPos);
                 applyNewPos = false;
             }
 
             const bool itemsRemoved = (changedCount < 0);
             const bool itemsInserted = (changedCount > 0);
             if (itemsRemoved && (i >= changedIndex)) {
                 // The item is located after the removed items. Animate the moving of the position.
                 applyNewPos = !moveWidget(widget, newPos);
             } else if (itemsInserted && i >= changedIndex) {
                 // The item is located after the first inserted item
                 if (i <= changedIndex + changedCount - 1) {
                     // The item is an inserted item. Animate the appearing of the item.
                     // For performance reasons no animation is done when changedCount is equal
                     // to all available items.
                     if (changedCount < m_model->count()) {
                         m_animation->start(widget, KItemListViewAnimation::CreateAnimation);
                     }
                 } else if (!m_animation->isStarted(widget, KItemListViewAnimation::CreateAnimation)) {
                     // The item was already there before, so animate the moving of the position.
                     // No moving animation is done if the item is animated by a create animation: This
                     // prevents a "move animation mess" when inserting several ranges in parallel.
                     applyNewPos = !moveWidget(widget, newPos);
                 }
             } else if (!itemsRemoved && !itemsInserted && !wasHidden) {
                 // The size of the view might have been changed. Animate the moving of the position.
                 applyNewPos = !moveWidget(widget, newPos);
             }
         } else {
             m_animation->stop(widget);
         }
 
         if (applyNewPos) {
             widget->setPos(newPos);
         }
 
         Q_ASSERT(widget->index() == i);
         widget->setVisible(true);
 
         if (widget->size() != itemBounds.size()) {
             // Resize the widget for the item to the changed size.
             if (animate) {
                 // If a dynamic item size is used then no animation is done in the direction
                 // of the dynamic size.
                 if (m_itemSize.width() <= 0) {
                     // The width is dynamic, apply the new width without animation.
                     widget->resize(itemBounds.width(), widget->size().height());
                 } else if (m_itemSize.height() <= 0) {
                     // The height is dynamic, apply the new height without animation.
                     widget->resize(widget->size().width(), itemBounds.height());
                 }
                 m_animation->start(widget, KItemListViewAnimation::ResizeAnimation, itemBounds.size());
             } else {
                 widget->resize(itemBounds.size());
             }
         }
 
         // Updating the cell-information must be done as last step: The decision whether the
         // moving-animation should be started at all is based on the previous cell-information.
         const Cell cell(m_layouter->itemColumn(i), m_layouter->itemRow(i));
         m_visibleCells.insert(i, cell);
     }
 
     // Delete invisible KItemListWidget instances that have not been reused
     foreach (int index, reusableItems) {
         recycleWidget(m_visibleItems.value(index));
     }
 
     if (supportsExpanding && firstSibblingIndex >= 0) {
         Q_ASSERT(lastSibblingIndex >= 0);
         updateSiblingsInformation(firstSibblingIndex, lastSibblingIndex);
     }
 
     if (m_grouped) {
         // Update the layout of all visible group headers
         QHashIterator<KItemListWidget*, KItemListGroupHeader*> it(m_visibleGroups);
         while (it.hasNext()) {
             it.next();
             updateGroupHeaderLayout(it.key());
         }
     }
 
     emitOffsetChanges();
 }
 
 QList<int> KItemListView::recycleInvisibleItems(int firstVisibleIndex,
                                                 int lastVisibleIndex,
                                                 LayoutAnimationHint hint)
 {
     // Determine all items that are completely invisible and might be
     // reused for items that just got (at least partly) visible. If the
     // animation hint is set to 'Animation' items that do e.g. an animated
     // moving of their position are not marked as invisible: This assures
     // that a scrolling inside the view can be done without breaking an animation.
 
     QList<int> items;
 
     QHashIterator<int, KItemListWidget*> it(m_visibleItems);
     while (it.hasNext()) {
         it.next();
 
         KItemListWidget* widget = it.value();
         const int index = widget->index();
         const bool invisible = (index < firstVisibleIndex) || (index > lastVisibleIndex);
 
         if (invisible) {
             if (m_animation->isStarted(widget)) {
                 if (hint == NoAnimation) {
                     // Stopping the animation will call KItemListView::slotAnimationFinished()
                     // and the widget will be recycled if necessary there.
                     m_animation->stop(widget);
                 }
             } else {
                 widget->setVisible(false);
                 items.append(index);
 
                 if (m_grouped) {
                     recycleGroupHeaderForWidget(widget);
                 }
             }
         }
     }
 
     return items;
 }
 
 bool KItemListView::moveWidget(KItemListWidget* widget,const QPointF& newPos)
 {
     if (widget->pos() == newPos) {
         return false;
     }
 
     bool startMovingAnim = false;
 
     if (m_itemSize.isEmpty()) {
         // The items are not aligned in a grid but either as columns or rows.
         startMovingAnim = true;
     } else {
         // When having a grid the moving-animation should only be started, if it is done within
         // one row in the vertical scroll-orientation or one column in the horizontal scroll-orientation.
         // Otherwise instead of a moving-animation a create-animation on the new position will be used
         // instead. This is done to prevent overlapping (and confusing) moving-animations.
         const int index = widget->index();
         const Cell cell = m_visibleCells.value(index);
         if (cell.column >= 0 && cell.row >= 0) {
             if (scrollOrientation() == Qt::Vertical) {
                 startMovingAnim = (cell.row == m_layouter->itemRow(index));
             } else {
                 startMovingAnim = (cell.column == m_layouter->itemColumn(index));
             }
         }
     }
 
     if (startMovingAnim) {
         m_animation->start(widget, KItemListViewAnimation::MovingAnimation, newPos);
         return true;
     }
 
     m_animation->stop(widget);
     m_animation->start(widget, KItemListViewAnimation::CreateAnimation);
     return false;
 }
 
 void KItemListView::emitOffsetChanges()
 {
     const qreal newScrollOffset = m_layouter->scrollOffset();
     if (m_oldScrollOffset != newScrollOffset) {
         emit scrollOffsetChanged(newScrollOffset, m_oldScrollOffset);
         m_oldScrollOffset = newScrollOffset;
     }
 
     const qreal newMaximumScrollOffset = m_layouter->maximumScrollOffset();
     if (m_oldMaximumScrollOffset != newMaximumScrollOffset) {
         emit maximumScrollOffsetChanged(newMaximumScrollOffset, m_oldMaximumScrollOffset);
         m_oldMaximumScrollOffset = newMaximumScrollOffset;
     }
 
     const qreal newItemOffset = m_layouter->itemOffset();
     if (m_oldItemOffset != newItemOffset) {
         emit itemOffsetChanged(newItemOffset, m_oldItemOffset);
         m_oldItemOffset = newItemOffset;
     }
 
     const qreal newMaximumItemOffset = m_layouter->maximumItemOffset();
     if (m_oldMaximumItemOffset != newMaximumItemOffset) {
         emit maximumItemOffsetChanged(newMaximumItemOffset, m_oldMaximumItemOffset);
         m_oldMaximumItemOffset = newMaximumItemOffset;
     }
 }
 
 KItemListWidget* KItemListView::createWidget(int index)
 {
     KItemListWidget* widget = widgetCreator()->create(this);
     widget->setFlag(QGraphicsItem::ItemStacksBehindParent);
 
     m_visibleItems.insert(index, widget);
     m_visibleCells.insert(index, Cell());
     updateWidgetProperties(widget, index);
     initializeItemListWidget(widget);
     return widget;
 }
 
 void KItemListView::recycleWidget(KItemListWidget* widget)
 {
     if (m_grouped) {
         recycleGroupHeaderForWidget(widget);
     }
 
     const int index = widget->index();
     m_visibleItems.remove(index);
     m_visibleCells.remove(index);
 
     widgetCreator()->recycle(widget);
 }
 
 void KItemListView::setWidgetIndex(KItemListWidget* widget, int index)
 {
     const int oldIndex = widget->index();
     m_visibleItems.remove(oldIndex);
     m_visibleCells.remove(oldIndex);
 
     m_visibleItems.insert(index, widget);
     m_visibleCells.insert(index, Cell());
 
     widget->setIndex(index);
 }
 
 void KItemListView::moveWidgetToIndex(KItemListWidget* widget, int index)
 {
     const int oldIndex = widget->index();
     const Cell oldCell = m_visibleCells.value(oldIndex);
 
     setWidgetIndex(widget, index);
 
     const Cell newCell(m_layouter->itemColumn(index), m_layouter->itemRow(index));
     const bool vertical = (scrollOrientation() == Qt::Vertical);
     const bool updateCell = (vertical  && oldCell.row    == newCell.row) ||
                             (!vertical && oldCell.column == newCell.column);
     if (updateCell) {
         m_visibleCells.insert(index, newCell);
     }
 }
 
 void KItemListView::setLayouterSize(const QSizeF& size, SizeType sizeType)
 {
     switch (sizeType) {
     case LayouterSize: m_layouter->setSize(size); break;
     case ItemSize: m_layouter->setItemSize(size); break;
     default: break;
     }
 }
 
 void KItemListView::updateWidgetProperties(KItemListWidget* widget, int index)
 {
     widget->setVisibleRoles(m_visibleRoles);
     updateWidgetColumnWidths(widget);
     widget->setStyleOption(m_styleOption);
 
     const KItemListSelectionManager* selectionManager = m_controller->selectionManager();
 
     // In SingleSelection mode (e.g., in the Places Panel), the current item is
     // always the selected item. It is not necessary to highlight the current item then.
     if (m_controller->selectionBehavior() != KItemListController::SingleSelection) {
         widget->setCurrent(index == selectionManager->currentItem());
     }
     widget->setSelected(selectionManager->isSelected(index));
     widget->setHovered(false);
     widget->setEnabledSelectionToggle(enabledSelectionToggles());
     widget->setIndex(index);
     widget->setData(m_model->data(index));
     widget->setSiblingsInformation(QBitArray());
     updateAlternateBackgroundForWidget(widget);
 
     if (m_grouped) {
         updateGroupHeaderForWidget(widget);
     }
 }
 
 void KItemListView::updateGroupHeaderForWidget(KItemListWidget* widget)
 {
     Q_ASSERT(m_grouped);
 
     const int index = widget->index();
     if (!m_layouter->isFirstGroupItem(index)) {
         // The widget does not represent the first item of a group
         // and hence requires no header
         recycleGroupHeaderForWidget(widget);
         return;
     }
 
     const QList<QPair<int, QVariant> > groups = model()->groups();
     if (groups.isEmpty() || !groupHeaderCreator()) {
         return;
     }
 
     KItemListGroupHeader* groupHeader = m_visibleGroups.value(widget);
     if (!groupHeader) {
         groupHeader = groupHeaderCreator()->create(this);
         groupHeader->setParentItem(widget);
         m_visibleGroups.insert(widget, groupHeader);
         connect(widget, &KItemListWidget::geometryChanged, this, &KItemListView::slotGeometryOfGroupHeaderParentChanged);
     }
     Q_ASSERT(groupHeader->parentItem() == widget);
 
     const int groupIndex = groupIndexForItem(index);
     Q_ASSERT(groupIndex >= 0);
     groupHeader->setData(groups.at(groupIndex).second);
     groupHeader->setRole(model()->sortRole());
     groupHeader->setStyleOption(m_styleOption);
     groupHeader->setScrollOrientation(scrollOrientation());
     groupHeader->setItemIndex(index);
 
     groupHeader->show();
 }
 
 void KItemListView::updateGroupHeaderLayout(KItemListWidget* widget)
 {
     KItemListGroupHeader* groupHeader = m_visibleGroups.value(widget);
     Q_ASSERT(groupHeader);
 
     const int index = widget->index();
     const QRectF groupHeaderRect = m_layouter->groupHeaderRect(index);
     const QRectF itemRect = m_layouter->itemRect(index);
 
     // The group-header is a child of the itemlist widget. Translate the
     // group header position to the relative position.
     if (scrollOrientation() == Qt::Vertical) {
         // In the vertical scroll orientation the group header should always span
         // the whole width no matter which temporary position the parent widget
         // has. In this case the x-position and width will be adjusted manually.
         const qreal x = -widget->x() - itemOffset();
         const qreal width = maximumItemOffset();
         groupHeader->setPos(x, -groupHeaderRect.height());
         groupHeader->resize(width, groupHeaderRect.size().height());
     } else {
         groupHeader->setPos(groupHeaderRect.x() - itemRect.x(), -widget->y());
         groupHeader->resize(groupHeaderRect.size());
     }
 }
 
 void KItemListView::recycleGroupHeaderForWidget(KItemListWidget* widget)
 {
     KItemListGroupHeader* header = m_visibleGroups.value(widget);
     if (header) {
         header->setParentItem(0);
         groupHeaderCreator()->recycle(header);
         m_visibleGroups.remove(widget);
         disconnect(widget, &KItemListWidget::geometryChanged, this, &KItemListView::slotGeometryOfGroupHeaderParentChanged);
     }
 }
 
 void KItemListView::updateVisibleGroupHeaders()
 {
     Q_ASSERT(m_grouped);
     m_layouter->markAsDirty();
 
     QHashIterator<int, KItemListWidget*> it(m_visibleItems);
     while (it.hasNext()) {
         it.next();
         updateGroupHeaderForWidget(it.value());
     }
 }
 
 int KItemListView::groupIndexForItem(int index) const
 {
     Q_ASSERT(m_grouped);
 
     const QList<QPair<int, QVariant> > groups = model()->groups();
     if (groups.isEmpty()) {
         return -1;
     }
 
     int min = 0;
     int max = groups.count() - 1;
     int mid = 0;
     do {
         mid = (min + max) / 2;
         if (index > groups[mid].first) {
             min = mid + 1;
         } else {
             max = mid - 1;
         }
     } while (groups[mid].first != index && min <= max);
 
     if (min > max) {
         while (groups[mid].first > index && mid > 0) {
             --mid;
         }
     }
 
     return mid;
 }
 
 void KItemListView::updateAlternateBackgrounds()
 {
     QHashIterator<int, KItemListWidget*> it(m_visibleItems);
     while (it.hasNext()) {
         it.next();
         updateAlternateBackgroundForWidget(it.value());
     }
 }
 
 void KItemListView::updateAlternateBackgroundForWidget(KItemListWidget* widget)
 {
     bool enabled = useAlternateBackgrounds();
     if (enabled) {
         const int index = widget->index();
         enabled = (index & 0x1) > 0;
         if (m_grouped) {
             const int groupIndex = groupIndexForItem(index);
             if (groupIndex >= 0) {
                 const QList<QPair<int, QVariant> > groups = model()->groups();
                 const int indexOfFirstGroupItem = groups[groupIndex].first;
                 const int relativeIndex = index - indexOfFirstGroupItem;
                 enabled = (relativeIndex & 0x1) > 0;
             }
         }
     }
     widget->setAlternateBackground(enabled);
 }
 
 bool KItemListView::useAlternateBackgrounds() const
 {
     return m_itemSize.isEmpty() && m_visibleRoles.count() > 1;
 }
 
 QHash<QByteArray, qreal> KItemListView::preferredColumnWidths(const KItemRangeList& itemRanges) const
 {
     QElapsedTimer timer;
     timer.start();
 
     QHash<QByteArray, qreal> widths;
 
     // Calculate the minimum width for each column that is required
     // to show the headline unclipped.
     const QFontMetricsF fontMetrics(m_headerWidget->font());
     const int gripMargin   = m_headerWidget->style()->pixelMetric(QStyle::PM_HeaderGripMargin);
     const int headerMargin = m_headerWidget->style()->pixelMetric(QStyle::PM_HeaderMargin);
     foreach (const QByteArray& visibleRole, visibleRoles()) {
         const QString headerText = m_model->roleDescription(visibleRole);
         const qreal headerWidth = fontMetrics.width(headerText) + gripMargin + headerMargin * 2;
         widths.insert(visibleRole, headerWidth);
     }
 
     // Calculate the preferred column withs for each item and ignore values
     // smaller than the width for showing the headline unclipped.
     const KItemListWidgetCreatorBase* creator = widgetCreator();
     int calculatedItemCount = 0;
     bool maxTimeExceeded = false;
     foreach (const KItemRange& itemRange, itemRanges) {
         const int startIndex = itemRange.index;
         const int endIndex = startIndex + itemRange.count - 1;
 
         for (int i = startIndex; i <= endIndex; ++i) {
             foreach (const QByteArray& visibleRole, visibleRoles()) {
                 qreal maxWidth = widths.value(visibleRole, 0);
                 const qreal width = creator->preferredRoleColumnWidth(visibleRole, i, this);
                 maxWidth = qMax(width, maxWidth);
                 widths.insert(visibleRole, maxWidth);
             }
 
             if (calculatedItemCount > 100 && timer.elapsed() > 200) {
                 // When having several thousands of items calculating the sizes can get
                 // very expensive. We accept a possibly too small role-size in favour
                 // of having no blocking user interface.
                 maxTimeExceeded = true;
                 break;
             }
             ++calculatedItemCount;
         }
         if (maxTimeExceeded) {
             break;
         }
     }
 
     return widths;
 }
 
 void KItemListView::applyColumnWidthsFromHeader()
 {
     // Apply the new size to the layouter
     const qreal requiredWidth = columnWidthsSum();
     const QSizeF dynamicItemSize(qMax(size().width(), requiredWidth),
                                  m_itemSize.height());
     m_layouter->setItemSize(dynamicItemSize);
 
     // Update the role sizes for all visible widgets
     QHashIterator<int, KItemListWidget*> it(m_visibleItems);
     while (it.hasNext()) {
         it.next();
         updateWidgetColumnWidths(it.value());
     }
 }
 
 void KItemListView::updateWidgetColumnWidths(KItemListWidget* widget)
 {
     foreach (const QByteArray& role, m_visibleRoles) {
         widget->setColumnWidth(role, m_headerWidget->columnWidth(role));
     }
 }
 
 void KItemListView::updatePreferredColumnWidths(const KItemRangeList& itemRanges)
 {
     Q_ASSERT(m_itemSize.isEmpty());
     const int itemCount = m_model->count();
     int rangesItemCount = 0;
     foreach (const KItemRange& range, itemRanges) {
         rangesItemCount += range.count;
     }
 
     if (itemCount == rangesItemCount) {
         const QHash<QByteArray, qreal> preferredWidths = preferredColumnWidths(itemRanges);
         foreach (const QByteArray& role, m_visibleRoles) {
             m_headerWidget->setPreferredColumnWidth(role, preferredWidths.value(role));
         }
     } else {
         // Only a sub range of the roles need to be determined.
         // The chances are good that the widths of the sub ranges
         // already fit into the available widths and hence no
         // expensive update might be required.
         bool changed = false;
 
         const QHash<QByteArray, qreal> updatedWidths = preferredColumnWidths(itemRanges);
         QHashIterator<QByteArray, qreal> it(updatedWidths);
         while (it.hasNext()) {
             it.next();
             const QByteArray& role = it.key();
             const qreal updatedWidth = it.value();
             const qreal currentWidth = m_headerWidget->preferredColumnWidth(role);
             if (updatedWidth > currentWidth) {
                 m_headerWidget->setPreferredColumnWidth(role, updatedWidth);
                 changed = true;
             }
         }
 
         if (!changed) {
             // All the updated sizes are smaller than the current sizes and no change
             // of the stretched roles-widths is required
             return;
         }
     }
 
     if (m_headerWidget->automaticColumnResizing()) {
         applyAutomaticColumnWidths();
     }
 }
 
 void KItemListView::updatePreferredColumnWidths()
 {
     if (m_model) {
         updatePreferredColumnWidths(KItemRangeList() << KItemRange(0, m_model->count()));
     }
 }
 
 void KItemListView::applyAutomaticColumnWidths()
 {
     Q_ASSERT(m_itemSize.isEmpty());
     Q_ASSERT(m_headerWidget->automaticColumnResizing());
     if (m_visibleRoles.isEmpty()) {
         return;
     }
 
     // Calculate the maximum size of an item by considering the
     // visible role sizes and apply them to the layouter. If the
     // size does not use the available view-size the size of the
     // first role will get stretched.
 
     foreach (const QByteArray& role, m_visibleRoles) {
         const qreal preferredWidth = m_headerWidget->preferredColumnWidth(role);
         m_headerWidget->setColumnWidth(role, preferredWidth);
     }
 
     const QByteArray firstRole = m_visibleRoles.first();
     qreal firstColumnWidth = m_headerWidget->columnWidth(firstRole);
     QSizeF dynamicItemSize = m_itemSize;
 
     qreal requiredWidth = columnWidthsSum();
     const qreal availableWidth = size().width();
     if (requiredWidth < availableWidth) {
         // Stretch the first column to use the whole remaining width
         firstColumnWidth += availableWidth - requiredWidth;
         m_headerWidget->setColumnWidth(firstRole, firstColumnWidth);
     } else if (requiredWidth > availableWidth && m_visibleRoles.count() > 1) {
         // Shrink the first column to be able to show as much other
         // columns as possible
         qreal shrinkedFirstColumnWidth = firstColumnWidth - requiredWidth + availableWidth;
 
         // TODO: A proper calculation of the minimum width depends on the implementation
         // of KItemListWidget. Probably a kind of minimum size-hint should be introduced
         // later.
         const qreal minWidth = qMin(firstColumnWidth, qreal(m_styleOption.iconSize * 2 + 200));
         if (shrinkedFirstColumnWidth < minWidth) {
             shrinkedFirstColumnWidth = minWidth;
         }
 
         m_headerWidget->setColumnWidth(firstRole, shrinkedFirstColumnWidth);
         requiredWidth -= firstColumnWidth - shrinkedFirstColumnWidth;
     }
 
     dynamicItemSize.rwidth() = qMax(requiredWidth, availableWidth);
 
     m_layouter->setItemSize(dynamicItemSize);
 
     // Update the role sizes for all visible widgets
     QHashIterator<int, KItemListWidget*> it(m_visibleItems);
     while (it.hasNext()) {
         it.next();
         updateWidgetColumnWidths(it.value());
     }
 }
 
 qreal KItemListView::columnWidthsSum() const
 {
     qreal widthsSum = 0;
     foreach (const QByteArray& role, m_visibleRoles) {
         widthsSum += m_headerWidget->columnWidth(role);
     }
     return widthsSum;
 }
 
 QRectF KItemListView::headerBoundaries() const
 {
     return m_headerWidget->isVisible() ? m_headerWidget->geometry() : QRectF();
 }
 
 bool KItemListView::changesItemGridLayout(const QSizeF& newGridSize,
                                           const QSizeF& newItemSize,
                                           const QSizeF& newItemMargin) const
 {
     if (newItemSize.isEmpty() || newGridSize.isEmpty()) {
         return false;
     }
 
     if (m_layouter->scrollOrientation() == Qt::Vertical) {
         const qreal itemWidth = m_layouter->itemSize().width();
         if (itemWidth > 0) {
             const int newColumnCount = itemsPerSize(newGridSize.width(),
                                                     newItemSize.width(),
                                                     newItemMargin.width());
             if (m_model->count() > newColumnCount) {
                 const int oldColumnCount = itemsPerSize(m_layouter->size().width(),
                                                         itemWidth,
                                                         m_layouter->itemMargin().width());
                 return oldColumnCount != newColumnCount;
             }
         }
     } else {
         const qreal itemHeight = m_layouter->itemSize().height();
         if (itemHeight > 0) {
             const int newRowCount = itemsPerSize(newGridSize.height(),
                                                  newItemSize.height(),
                                                  newItemMargin.height());
             if (m_model->count() > newRowCount) {
                 const int oldRowCount = itemsPerSize(m_layouter->size().height(),
                                                      itemHeight,
                                                      m_layouter->itemMargin().height());
                 return oldRowCount != newRowCount;
             }
         }
     }
 
     return false;
 }
 
 bool KItemListView::animateChangedItemCount(int changedItemCount) const
 {
     if (m_itemSize.isEmpty()) {
         // We have only columns or only rows, but no grid: An animation is usually
         // welcome when inserting or removing items.
         return !supportsItemExpanding();
     }
 
     if (m_layouter->size().isEmpty() || m_layouter->itemSize().isEmpty()) {
         return false;
     }
 
     const int maximum = (scrollOrientation() == Qt::Vertical)
                         ? m_layouter->size().width()  / m_layouter->itemSize().width()
                         : m_layouter->size().height() / m_layouter->itemSize().height();
     // Only animate if up to 2/3 of a row or column are inserted or removed
     return changedItemCount <= maximum * 2 / 3;
 }
 
 
 bool KItemListView::scrollBarRequired(const QSizeF& size) const
 {
     const QSizeF oldSize = m_layouter->size();
 
     m_layouter->setSize(size);
     const qreal maxOffset = m_layouter->maximumScrollOffset();
     m_layouter->setSize(oldSize);
 
     return m_layouter->scrollOrientation() == Qt::Vertical ? maxOffset > size.height()
                                                            : maxOffset > size.width();
 }
 
 int KItemListView::showDropIndicator(const QPointF& pos)
 {
     QHashIterator<int, KItemListWidget*> it(m_visibleItems);
     while (it.hasNext()) {
         it.next();
         const KItemListWidget* widget = it.value();
 
         const QPointF mappedPos = widget->mapFromItem(this, pos);
         const QRectF rect = itemRect(widget->index());
         if (mappedPos.y() >= 0 && mappedPos.y() <= rect.height()) {
             if (m_model->supportsDropping(widget->index())) {
                 // Keep 30% of the rectangle as the gap instead of always having a fixed gap
                 const int gap = qMax(qreal(4.0), qreal(0.3) * rect.height());
                 if (mappedPos.y() >= gap && mappedPos.y() <= rect.height() - gap) {
                     return -1;
                 }
             }
 
             const bool isAboveItem = (mappedPos.y () < rect.height() / 2);
             const qreal y = isAboveItem ? rect.top() : rect.bottom();
 
             const QRectF draggingInsertIndicator(rect.left(), y, rect.width(), 1);
             if (m_dropIndicator != draggingInsertIndicator) {
                 m_dropIndicator = draggingInsertIndicator;
                 update();
             }
 
             int index = widget->index();
             if (!isAboveItem) {
                 ++index;
             }
             return index;
         }
     }
 
     const QRectF firstItemRect = itemRect(firstVisibleIndex());
     return (pos.y() <= firstItemRect.top()) ? 0 : -1;
 }
 
 void KItemListView::hideDropIndicator()
 {
     if (!m_dropIndicator.isNull()) {
         m_dropIndicator = QRectF();
         update();
     }
 }
 
 void KItemListView::updateGroupHeaderHeight()
 {
     qreal groupHeaderHeight = m_styleOption.fontMetrics.height();
     qreal groupHeaderMargin = 0;
 
     if (scrollOrientation() == Qt::Horizontal) {
         // The vertical margin above and below the header should be
         // equal to the horizontal margin, not the vertical margin
         // from m_styleOption.
         groupHeaderHeight += 2 * m_styleOption.horizontalMargin;
         groupHeaderMargin = m_styleOption.horizontalMargin;
     } else if (m_itemSize.isEmpty()){
         groupHeaderHeight += 4 * m_styleOption.padding;
         groupHeaderMargin = m_styleOption.iconSize / 2;
     } else {
         groupHeaderHeight += 2 * m_styleOption.padding + m_styleOption.verticalMargin;
         groupHeaderMargin = m_styleOption.iconSize / 4;
     }
     m_layouter->setGroupHeaderHeight(groupHeaderHeight);
     m_layouter->setGroupHeaderMargin(groupHeaderMargin);
 
     updateVisibleGroupHeaders();
 }
 
 void KItemListView::updateSiblingsInformation(int firstIndex, int lastIndex)
 {
     if (!supportsItemExpanding() || !m_model) {
         return;
     }
 
     if (firstIndex < 0 || lastIndex < 0) {
         firstIndex = m_layouter->firstVisibleIndex();
         lastIndex  = m_layouter->lastVisibleIndex();
     } else {
         const bool isRangeVisible = (firstIndex <= m_layouter->lastVisibleIndex() &&
                                      lastIndex  >= m_layouter->firstVisibleIndex());
         if (!isRangeVisible) {
             return;
         }
     }
 
     int previousParents = 0;
     QBitArray previousSiblings;
 
     // The rootIndex describes the first index where the siblings get
     // calculated from. For the calculation the upper most parent item
     // is required. For performance reasons it is checked first whether
     // the visible items before or after the current range already
     // contain a siblings information which can be used as base.
     int rootIndex = firstIndex;
 
     KItemListWidget* widget = m_visibleItems.value(firstIndex - 1);
     if (!widget) {
         // There is no visible widget before the range, check whether there
         // is one after the range:
         widget = m_visibleItems.value(lastIndex + 1);
         if (widget) {
             // The sibling information of the widget may only be used if
             // all items of the range have the same number of parents.
             const int parents = m_model->expandedParentsCount(lastIndex + 1);
             for (int i = lastIndex; i >= firstIndex; --i) {
                 if (m_model->expandedParentsCount(i) != parents) {
                     widget = 0;
                     break;
                 }
             }
         }
     }
 
     if (widget) {
         // Performance optimization: Use the sibling information of the visible
         // widget beside the given range.
         previousSiblings = widget->siblingsInformation();
         if (previousSiblings.isEmpty()) {
             return;
         }
         previousParents = previousSiblings.count() - 1;
         previousSiblings.truncate(previousParents);
     } else {
         // Potentially slow path: Go back to the upper most parent of firstIndex
         // to be able to calculate the initial value for the siblings.
         while (rootIndex > 0 && m_model->expandedParentsCount(rootIndex) > 0) {
             --rootIndex;
         }
     }
 
     Q_ASSERT(previousParents >= 0);
     for (int i = rootIndex; i <= lastIndex; ++i) {
         // Update the parent-siblings in case if the current item represents
         // a child or an upper parent.
         const int currentParents = m_model->expandedParentsCount(i);
         Q_ASSERT(currentParents >= 0);
         if (previousParents < currentParents) {
             previousParents = currentParents;
             previousSiblings.resize(currentParents);
             previousSiblings.setBit(currentParents - 1, hasSiblingSuccessor(i - 1));
         } else if (previousParents > currentParents) {
             previousParents = currentParents;
             previousSiblings.truncate(currentParents);
         }
 
         if (i >= firstIndex) {
             // The index represents a visible item. Apply the parent-siblings
             // and update the sibling of the current item.
             KItemListWidget* widget = m_visibleItems.value(i);
             if (!widget) {
                 continue;
             }
 
             QBitArray siblings = previousSiblings;
             siblings.resize(siblings.count() + 1);
             siblings.setBit(siblings.count() - 1, hasSiblingSuccessor(i));
 
             widget->setSiblingsInformation(siblings);
         }
     }
 }
 
 bool KItemListView::hasSiblingSuccessor(int index) const
 {
     bool hasSuccessor = false;
     const int parentsCount = m_model->expandedParentsCount(index);
     int successorIndex = index + 1;
 
     // Search the next sibling
     const int itemCount = m_model->count();
     while (successorIndex < itemCount) {
         const int currentParentsCount = m_model->expandedParentsCount(successorIndex);
         if (currentParentsCount == parentsCount) {
             hasSuccessor = true;
             break;
         } else if (currentParentsCount < parentsCount) {
             break;
         }
         ++successorIndex;
     }
 
     if (m_grouped && hasSuccessor) {
         // If the sibling is part of another group, don't mark it as
         // successor as the group header is between the sibling connections.
         for (int i = index + 1; i <= successorIndex; ++i) {
             if (m_layouter->isFirstGroupItem(i)) {
                 hasSuccessor = false;
                 break;
             }
         }
     }
 
     return hasSuccessor;
 }
 
 void KItemListView::disconnectRoleEditingSignals(int index)
 {
     KItemListWidget* widget = m_visibleItems.value(index);
     if (!widget) {
         return;
     }
 
     disconnect(widget, &KItemListWidget::roleEditingCanceled, this, nullptr);
     disconnect(widget, &KItemListWidget::roleEditingFinished, this, nullptr);
 }
 
 int KItemListView::calculateAutoScrollingIncrement(int pos, int range, int oldInc)
 {
     int inc = 0;
 
     const int minSpeed = 4;
     const int maxSpeed = 128;
     const int speedLimiter = 96;
     const int autoScrollBorder = 64;
 
     // Limit the increment that is allowed to be added in comparison to 'oldInc'.
     // This assures that the autoscrolling speed grows gradually.
     const int incLimiter = 1;
 
     if (pos < autoScrollBorder) {
         inc = -minSpeed + qAbs(pos - autoScrollBorder) * (pos - autoScrollBorder) / speedLimiter;
         inc = qMax(inc, -maxSpeed);
         inc = qMax(inc, oldInc - incLimiter);
     } else if (pos > range - autoScrollBorder) {
         inc = minSpeed + qAbs(pos - range + autoScrollBorder) * (pos - range + autoScrollBorder) / speedLimiter;
         inc = qMin(inc, maxSpeed);
         inc = qMin(inc, oldInc + incLimiter);
     }
 
     return inc;
 }
 
 int KItemListView::itemsPerSize(qreal size, qreal itemSize, qreal itemMargin)
 {
     const qreal availableSize = size - itemMargin;
     const int count = availableSize / (itemSize + itemMargin);
     return count;
 }
 
 
 
 KItemListCreatorBase::~KItemListCreatorBase()
 {
     qDeleteAll(m_recycleableWidgets);
     qDeleteAll(m_createdWidgets);
 }
 
 void KItemListCreatorBase::addCreatedWidget(QGraphicsWidget* widget)
 {
     m_createdWidgets.insert(widget);
 }
 
 void KItemListCreatorBase::pushRecycleableWidget(QGraphicsWidget* widget)
 {
     Q_ASSERT(m_createdWidgets.contains(widget));
     m_createdWidgets.remove(widget);
 
     if (m_recycleableWidgets.count() < 100) {
         m_recycleableWidgets.append(widget);
         widget->setVisible(false);
     } else {
         delete widget;
     }
 }
 
 QGraphicsWidget* KItemListCreatorBase::popRecycleableWidget()
 {
     if (m_recycleableWidgets.isEmpty()) {
         return 0;
     }
 
     QGraphicsWidget* widget = m_recycleableWidgets.takeLast();
     m_createdWidgets.insert(widget);
     return widget;
 }
 
 KItemListWidgetCreatorBase::~KItemListWidgetCreatorBase()
 {
 }
 
 void KItemListWidgetCreatorBase::recycle(KItemListWidget* widget)
 {
     widget->setParentItem(0);
     widget->setOpacity(1.0);
     pushRecycleableWidget(widget);
 }
 
 KItemListGroupHeaderCreatorBase::~KItemListGroupHeaderCreatorBase()
 {
 }
 
 void KItemListGroupHeaderCreatorBase::recycle(KItemListGroupHeader* header)
 {
     header->setOpacity(1.0);
     pushRecycleableWidget(header);
 }
 
diff --git a/src/kitemviews/kitemlistview.h b/src/kitemviews/kitemlistview.h
index ed1199877..e64ac7e31 100644
--- a/src/kitemviews/kitemlistview.h
+++ b/src/kitemviews/kitemlistview.h
@@ -1,916 +1,917 @@
 /***************************************************************************
  *   Copyright (C) 2011 by Peter Penz <peter.penz19@gmail.com>             *
  *                                                                         *
  *   Based on the Itemviews NG project from Trolltech Labs:                *
  *   http://qt.gitorious.org/qt-labs/itemviews-ng                          *
  *                                                                         *
  *   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 KITEMLISTVIEW_H
 #define KITEMLISTVIEW_H
 
 #include "dolphin_export.h"
 
 #include <kitemviews/kstandarditemlistgroupheader.h>
 #include <kitemviews/kitemliststyleoption.h>
 #include <kitemviews/kitemlistwidget.h>
 #include <kitemviews/kitemmodelbase.h>
 #include <kitemviews/private/kitemlistviewanimation.h>
 #include <QGraphicsWidget>
 #include <QSet>
 
 class KItemListController;
 class KItemListGroupHeaderCreatorBase;
 class KItemListHeader;
 class KItemListHeaderWidget;
 class KItemListSizeHintResolver;
 class KItemListRubberBand;
 class KItemListViewAnimation;
 class KItemListViewLayouter;
 class KItemListWidget;
 class KItemListWidgetInformant;
 class KItemListWidgetCreatorBase;
 class QTimer;
 
 /**
  * @brief Represents the view of an item-list.
  *
  * The view is responsible for showing the items of the model within
  * a GraphicsItem. Each visible item is represented by a KItemListWidget.
  *
  * The created view must be applied to the KItemListController with
  * KItemListController::setView() or with the constructor of
  * KItemListController.
  *
  * @see KItemListWidget
  * @see KItemModelBase
  */
 class DOLPHIN_EXPORT KItemListView : public QGraphicsWidget
 {
     Q_OBJECT
 
     Q_PROPERTY(qreal scrollOffset READ scrollOffset WRITE setScrollOffset)
     Q_PROPERTY(qreal itemOffset READ itemOffset WRITE setItemOffset)
 
 public:
     KItemListView(QGraphicsWidget* parent = 0);
     virtual ~KItemListView();
 
     /**
      * Offset of the scrollbar that represents the scroll-orientation
      * (see setScrollOrientation()).
      */
     void setScrollOffset(qreal offset);
     qreal scrollOffset() const;
 
     qreal maximumScrollOffset() const;
 
     /**
      * Offset related to an item, that does not fit into the available
      * size of the listview. If the scroll-orientation is vertical
      * the item-offset describes the offset of the horizontal axe, if
      * the scroll-orientation is horizontal the item-offset describes
      * the offset of the vertical axe.
      */
     void setItemOffset(qreal scrollOffset);
     qreal itemOffset() const;
 
     qreal maximumItemOffset() const;
 
     int maximumVisibleItems() const;
 
     void setVisibleRoles(const QList<QByteArray>& roles);
     QList<QByteArray> visibleRoles() const;
 
     /**
      * If set to true an automatic scrolling is done as soon as the
      * mouse is moved near the borders of the view. Per default
      * the automatic scrolling is turned off.
      */
     void setAutoScroll(bool enabled);
     bool autoScroll() const;
 
     /**
      * If set to true selection-toggles will be shown when hovering
      * an item. Per default the selection-toggles are disabled.
      */
     void setEnabledSelectionToggles(bool enabled);
     bool enabledSelectionToggles() const;
 
     /**
      * @return Controller of the item-list. The controller gets
      *         initialized by KItemListController::setView() and will
      *         result in calling KItemListController::onControllerChanged().
      */
     KItemListController* controller() const;
 
     /**
      * @return Model of the item-list. The model gets
      *         initialized by KItemListController::setModel() and will
      *         result in calling KItemListController::onModelChanged().
      */
     KItemModelBase* model() const;
 
     /**
      * Sets the creator that creates a widget showing the
      * content of one model-item. Usually it is sufficient
      * to implement a custom widget X derived from KItemListWidget and
      * set the creator by:
      * <code>
      * itemListView->setWidgetCreator(new KItemListWidgetCreator<X>());
      * </code>
      * The ownership of the widget creator is transferred to
      * the item-list view.
      **/
     void setWidgetCreator(KItemListWidgetCreatorBase* widgetCreator);
     KItemListWidgetCreatorBase* widgetCreator() const;
 
     /**
      * Sets the creator that creates a group header. Usually it is sufficient
      * to implement a custom header widget X derived from KItemListGroupHeader and
      * set the creator by:
      * <code>
      * itemListView->setGroupHeaderCreator(new KItemListGroupHeaderCreator<X>());
      * </code>
      * The ownership of the gropup header creator is transferred to
      * the item-list view.
      **/
     void setGroupHeaderCreator(KItemListGroupHeaderCreatorBase* groupHeaderCreator);
     KItemListGroupHeaderCreatorBase* groupHeaderCreator() const;
 
     /**
      * @return The basic size of all items. The size of an item may be larger than
      *         the basic size (see KItemListView::itemRect()).
      */
     QSizeF itemSize() const;
 
     /**
      * @return The size hint of all items. It is provided by the KItemListSizeHintResolver.
      */
     QSizeF itemSizeHint() const;
 
     const KItemListStyleOption& styleOption() const;
 
     virtual void setGeometry(const QRectF& rect) Q_DECL_OVERRIDE;
 
     /**
      * @return The page step which should be used by the vertical scroll bar.
      *         This is the height of the view except for the header widget.
      */
     qreal verticalPageStep() const;
 
     /**
      * @return Index of the item that is below the point \a pos.
      *         The position is relative to the upper right of
      *         the visible area. Only (at least partly) visible
      *         items are considered. -1 is returned if no item is
      *         below the position.
      */
     int itemAt(const QPointF& pos) const;
     bool isAboveSelectionToggle(int index, const QPointF& pos) const;
     bool isAboveExpansionToggle(int index, const QPointF& pos) const;
+    bool isAboveText(int index, const QPointF& pos) const;
 
     /**
      * @return Index of the first item that is at least partly visible.
      *         -1 is returned if the model contains no items.
      */
     int firstVisibleIndex() const;
 
     /**
      * @return Index of the last item that is at least partly visible.
      *         -1 is returned if the model contains no items.
      */
     int lastVisibleIndex() const;
 
     /**
      * Calculates the required size for all items in the model.
      * It might be larger than KItemListView::itemSize().
      * In this case the layout grid will be stretched to assure an
      * unclipped item.
      *
      * @note the logical height (width) is actually the
      * width (height) if the scroll orientation is Qt::Vertical!
      */
     void calculateItemSizeHints(QVector<qreal>& logicalHeightHints, qreal& logicalWidthHint) const;
 
     /**
      * If set to true, items having child-items can be expanded to show the child-items as
      * part of the view. Per default the expanding of items is is disabled. If expanding of
      * items is enabled, the methods KItemModelBase::setExpanded(), KItemModelBase::isExpanded(),
      * KItemModelBase::isExpandable() and KItemModelBase::expandedParentsCount()
      * must be reimplemented. The view-implementation
      * has to take care itself how to visually represent the expanded items provided
      * by the model.
      */
     void setSupportsItemExpanding(bool supportsExpanding);
     bool supportsItemExpanding() const;
 
     /**
      * @return The rectangle of the item relative to the top/left of
      *         the currently visible area (see KItemListView::offset()).
      */
     QRectF itemRect(int index) const;
 
     /**
      * @return The context rectangle of the item relative to the top/left of
      *         the currently visible area (see KItemListView::offset()). The
      *         context rectangle is defined by by the united rectangle of
      *         the icon rectangle and the text rectangle (see KItemListWidget::iconRect()
      *         and KItemListWidget::textRect()) and is useful as reference for e.g. aligning
      *         a tooltip or a context-menu for an item. Note that a context rectangle will
      *         only be returned for (at least partly) visible items. An empty rectangle will
      *         be returned for fully invisible items.
      */
     QRectF itemContextRect(int index) const;
 
     /**
      * Scrolls to the item with the index \a index so that the item
      * will be fully visible.
      */
     void scrollToItem(int index);
 
     /**
      * If several properties of KItemListView are changed synchronously, it is
      * recommended to encapsulate the calls between beginTransaction() and endTransaction().
      * This prevents unnecessary and expensive layout-calculations.
      */
     void beginTransaction();
 
     /**
      * Counterpart to beginTransaction(). The layout changes will only be animated if
      * all property changes between beginTransaction() and endTransaction() support
      * animations.
      */
     void endTransaction();
 
     bool isTransactionActive() const;
 
     /**
      * Turns on the header if \p visible is true. Per default the
      * header is not visible. Usually the header is turned on when
      * showing a classic "table-view" to describe the shown columns.
      */
     void setHeaderVisible(bool visible);
     bool isHeaderVisible() const;
 
     /**
      * @return Header of the list. The header is also available if it is not shown
      *         (see KItemListView::setHeaderShown()).
      */
     KItemListHeader* header() const;
 
     /**
      * @return Pixmap that is used for a drag operation based on the
      *         items given by \a indexes.
      */
     virtual QPixmap createDragPixmap(const KItemSet& indexes) const;
 
     /**
      * Lets the user edit the role \a role for item with the index \a index.
      */
     void editRole(int index, const QByteArray& role);
 
     virtual void paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget = 0) Q_DECL_OVERRIDE;
 
 signals:
     void scrollOrientationChanged(Qt::Orientation current, Qt::Orientation previous);
     void scrollOffsetChanged(qreal current, qreal previous);
     void maximumScrollOffsetChanged(qreal current, qreal previous);
     void itemOffsetChanged(qreal current, qreal previous);
     void maximumItemOffsetChanged(qreal current, qreal previous);
     void scrollTo(qreal newOffset);
 
     /**
      * Is emitted if the user has changed the sort order by clicking on a
      * header item (see KItemListView::setHeaderShown()). The sort order
      * of the model has already been adjusted to
      * the current sort order. Note that no signal will be emitted if the
      * sort order of the model has been changed without user interaction.
      */
     void sortOrderChanged(Qt::SortOrder current, Qt::SortOrder previous);
 
     /**
      * Is emitted if the user has changed the sort role by clicking on a
      * header item (see KItemListView::setHeaderShown()). The sort role
      * of the model has already been adjusted to
      * the current sort role. Note that no signal will be emitted if the
      * sort role of the model has been changed without user interaction.
      */
     void sortRoleChanged(const QByteArray& current, const QByteArray& previous);
 
     /**
      * Is emitted if the user has changed the visible roles by moving a header
      * item (see KItemListView::setHeaderShown()). Note that no signal will be
      * emitted if the roles have been changed without user interaction by
      * KItemListView::setVisibleRoles().
      */
     void visibleRolesChanged(const QList<QByteArray>& current, const QList<QByteArray>& previous);
 
     void roleEditingCanceled(int index, const QByteArray& role, const QVariant& value);
     void roleEditingFinished(int index, const QByteArray& role, const QVariant& value);
 
 protected:
     virtual QVariant itemChange(GraphicsItemChange change, const QVariant &value) Q_DECL_OVERRIDE;
     void setItemSize(const QSizeF& size);
     void setStyleOption(const KItemListStyleOption& option);
 
     /**
      * If the scroll-orientation is vertical, the items are ordered
      * from top to bottom (= default setting). If the scroll-orientation
      * is horizontal, the items are ordered from left to right.
      */
     void setScrollOrientation(Qt::Orientation orientation);
     Qt::Orientation scrollOrientation() const;
 
     /**
      * Factory method for creating a default widget-creator. The method will be used
      * in case if setWidgetCreator() has not been set by the application.
      * @return New instance of the widget-creator that should be used per
      *         default.
      */
     virtual KItemListWidgetCreatorBase* defaultWidgetCreator() const;
 
     /**
      * Factory method for creating a default group-header-creator. The method will be used
      * in case if setGroupHeaderCreator() has not been set by the application.
      * @return New instance of the group-header-creator that should be used per
      *         default.
      */
     virtual KItemListGroupHeaderCreatorBase* defaultGroupHeaderCreator() const;
 
     /**
      * Is called when creating a new KItemListWidget instance and allows derived
      * classes to do a custom initialization.
      */
     virtual void initializeItemListWidget(KItemListWidget* item);
 
     /**
      * @return True if at least one of the changed roles \p changedRoles might result
      *         in the need to update the item-size hint (see KItemListView::itemSizeHint()).
      *         Per default true is returned which means on each role-change of existing items
      *         the item-size hints are recalculated. For performance reasons it is recommended
      *         to return false in case if a role-change will not result in a changed
      *         item-size hint.
      */
     virtual bool itemSizeHintUpdateRequired(const QSet<QByteArray>& changedRoles) const;
 
     virtual void onControllerChanged(KItemListController* current, KItemListController* previous);
     virtual void onModelChanged(KItemModelBase* current, KItemModelBase* previous);
 
     virtual void onScrollOrientationChanged(Qt::Orientation current, Qt::Orientation previous);
     virtual void onItemSizeChanged(const QSizeF& current, const QSizeF& previous);
     virtual void onScrollOffsetChanged(qreal current, qreal previous);
     virtual void onVisibleRolesChanged(const QList<QByteArray>& current, const QList<QByteArray>& previous);
     virtual void onStyleOptionChanged(const KItemListStyleOption& current, const KItemListStyleOption& previous);
     virtual void onSupportsItemExpandingChanged(bool supportsExpanding);
 
     virtual void onTransactionBegin();
     virtual void onTransactionEnd();
 
     virtual bool event(QEvent* event) Q_DECL_OVERRIDE;
     virtual void mousePressEvent(QGraphicsSceneMouseEvent* event) Q_DECL_OVERRIDE;
     virtual void mouseMoveEvent(QGraphicsSceneMouseEvent* event) Q_DECL_OVERRIDE;
     virtual void dragEnterEvent(QGraphicsSceneDragDropEvent* event) Q_DECL_OVERRIDE;
     virtual void dragMoveEvent(QGraphicsSceneDragDropEvent* event) Q_DECL_OVERRIDE;
     virtual void dragLeaveEvent(QGraphicsSceneDragDropEvent* event) Q_DECL_OVERRIDE;
     virtual void dropEvent(QGraphicsSceneDragDropEvent* event) Q_DECL_OVERRIDE;
 
     QList<KItemListWidget*> visibleItemListWidgets() const;
 
     virtual void updateFont();
     virtual void updatePalette();
 
 protected slots:
     virtual void slotItemsInserted(const KItemRangeList& itemRanges);
     virtual void slotItemsRemoved(const KItemRangeList& itemRanges);
     virtual void slotItemsMoved(const KItemRange& itemRange, const QList<int>& movedToIndexes);
     virtual void slotItemsChanged(const KItemRangeList& itemRanges,
                                   const QSet<QByteArray>& roles);
     virtual void slotGroupsChanged();
 
     virtual void slotGroupedSortingChanged(bool current);
     virtual void slotSortOrderChanged(Qt::SortOrder current, Qt::SortOrder previous);
     virtual void slotSortRoleChanged(const QByteArray& current, const QByteArray& previous);
     virtual void slotCurrentChanged(int current, int previous);
     virtual void slotSelectionChanged(const KItemSet& current, const KItemSet& previous);
 
 private slots:
     void slotAnimationFinished(QGraphicsWidget* widget,
                                KItemListViewAnimation::AnimationType type);
     void slotLayoutTimerFinished();
 
     void slotRubberBandPosChanged();
     void slotRubberBandActivationChanged(bool active);
 
     /**
      * Is invoked if the column-width of one role in the header has
      * been changed by the user. The automatic resizing of columns
      * will be turned off as soon as this method has been called at
      * least once.
      */
     void slotHeaderColumnWidthChanged(const QByteArray& role,
                                       qreal currentWidth,
                                       qreal previousWidth);
 
     /**
      * Is invoked if a column has been moved by the user. Applies
      * the moved role to the view.
      */
     void slotHeaderColumnMoved(const QByteArray& role,
                                int currentIndex,
                                int previousIndex);
 
     /**
      * Triggers the autoscrolling if autoScroll() is enabled by checking the
      * current mouse position. If the mouse position is within the autoscroll
      * margins a timer will be started that periodically triggers the autoscrolling.
      */
     void triggerAutoScrolling();
 
     /**
      * Is invoked if the geometry of the parent-widget from a group-header has been
      * changed. The x-position and width of the group-header gets adjusted to assure
      * that it always spans the whole width even during temporary transitions of the
      * parent widget.
      */
     void slotGeometryOfGroupHeaderParentChanged();
 
     void slotRoleEditingCanceled(int index, const QByteArray& role, const QVariant& value);
     void slotRoleEditingFinished(int index, const QByteArray& role, const QVariant& value);
 
 private:
     enum LayoutAnimationHint
     {
         NoAnimation,
         Animation
     };
 
     enum SizeType
     {
         LayouterSize,
         ItemSize
     };
 
     void setController(KItemListController* controller);
     void setModel(KItemModelBase* model);
 
     KItemListRubberBand* rubberBand() const;
 
     void doLayout(LayoutAnimationHint hint, int changedIndex = 0, int changedCount = 0);
 
     /**
      * Helper method for doLayout: Returns a list of items that can be reused for the visible
      * area. Invisible group headers get recycled. The reusable items are items that are
      * invisible. If the animation hint is 'Animation' then items that are currently animated
      * won't be reused. Reusing items is faster in comparison to deleting invisible
      * items and creating a new instance for visible items.
      */
     QList<int> recycleInvisibleItems(int firstVisibleIndex,
                                      int lastVisibleIndex,
                                      LayoutAnimationHint hint);
 
     /**
      * Helper method for doLayout: Starts a moving-animation for the widget to the given
      * new position. The moving-animation is only started if the new position is within
      * the same row or column, otherwise the create-animation is used instead.
      * @return True if the moving-animation has been applied.
      */
     bool moveWidget(KItemListWidget* widget, const QPointF& newPos);
 
     void emitOffsetChanges();
 
     KItemListWidget* createWidget(int index);
     void recycleWidget(KItemListWidget* widget);
 
     /**
      * Changes the index of the widget to \a index and assures a consistent
      * update for m_visibleItems and m_visibleCells. The cell-information
      * for the new index will not be updated and be initialized as empty cell.
      */
     void setWidgetIndex(KItemListWidget* widget, int index);
 
     /**
      * Changes the index of the widget to \a index. In opposite to
      * setWidgetIndex() the cell-information for the widget gets updated.
      * This update gives doLayout() the chance to animate the moving
      * of the item visually (see moveWidget()).
      */
     void moveWidgetToIndex(KItemListWidget* widget, int index);
 
     /**
      * Helper method for prepareLayoutForIncreasedItemCount().
      */
     void setLayouterSize(const QSizeF& size, SizeType sizeType);
 
     /**
      * Helper method for createWidget() and setWidgetIndex() to update the properties
      * of the itemlist widget.
      */
     void updateWidgetProperties(KItemListWidget* widget, int index);
 
     /**
      * Helper method for updateWidgetPropertes() to create or update
      * the itemlist group-header.
      */
     void updateGroupHeaderForWidget(KItemListWidget* widget);
 
     /**
      * Updates the position and size of the group-header that belongs
      * to the itemlist widget \a widget. The given widget must represent
      * the first item of a group.
      */
     void updateGroupHeaderLayout(KItemListWidget* widget);
 
     /**
      * Recycles the group-header for the widget.
      */
     void recycleGroupHeaderForWidget(KItemListWidget* widget);
 
     /**
      * Helper method for slotGroupedSortingChanged(), slotSortOrderChanged()
      * and slotSortRoleChanged(): Iterates through all visible items and updates
      * the group-header widgets.
      */
     void updateVisibleGroupHeaders();
 
     /**
      * @return Index for the item in the list returned by KItemModelBase::groups()
      *         that represents the group where the item with the index \a index
      *         belongs to. -1 is returned if no groups are available.
      */
     int groupIndexForItem(int index) const;
 
     /**
      * Updates the alternate background for all visible items.
      * @see updateAlternateBackgroundForWidget()
      */
     void updateAlternateBackgrounds();
 
     /**
      * Updates the alternateBackground-property of the widget dependent
      * on the state of useAlternateBackgrounds() and the grouping state.
      */
     void updateAlternateBackgroundForWidget(KItemListWidget* widget);
 
     /**
      * @return True if alternate backgrounds should be used for the items.
      *         This is the case if an empty item-size is given and if there
      *         is more than one visible role.
      */
     bool useAlternateBackgrounds() const;
 
     /**
      * @param itemRanges Items that must be checked for getting the widths of columns.
      * @return           The preferred width of the column of each visible role. The width will
      *                   be respected if the width of the item size is <= 0 (see
      *                   KItemListView::setItemSize()). Per default an empty hash
      *                   is returned.
      */
     QHash<QByteArray, qreal> preferredColumnWidths(const KItemRangeList& itemRanges) const;
 
     /**
      * Applies the column-widths from m_headerWidget to the layout
      * of the view.
      */
     void applyColumnWidthsFromHeader();
 
     /**
      * Applies the column-widths from m_headerWidget to \a widget.
      */
     void updateWidgetColumnWidths(KItemListWidget* widget);
 
     /**
      * Updates the preferred column-widths of m_groupHeaderWidget by
      * invoking KItemListView::columnWidths().
      */
     void updatePreferredColumnWidths(const KItemRangeList& itemRanges);
 
     /**
      * Convenience method for
      * updatePreferredColumnWidths(KItemRangeList() << KItemRange(0, m_model->count()).
      */
     void updatePreferredColumnWidths();
 
     /**
      * Resizes the column-widths of m_headerWidget based on the preferred widths
      * and the vailable view-size.
      */
     void applyAutomaticColumnWidths();
 
     /**
      * @return Sum of the widths of all columns.
      */
     qreal columnWidthsSum() const;
 
     /**
      * @return Boundaries of the header. An empty rectangle is returned
      *         if no header is shown.
      */
     QRectF headerBoundaries() const;
 
     /**
      * @return True if the number of columns or rows will be changed when applying
      *         the new grid- and item-size. Used to determine whether an animation
      *         should be done when applying the new layout.
      */
     bool changesItemGridLayout(const QSizeF& newGridSize,
                                const QSizeF& newItemSize,
                                const QSizeF& newItemMargin) const;
 
     /**
      * @param changedItemCount Number of inserted  or removed items.
      * @return                 True if the inserting or removing of items should be animated.
      *                         No animation should be done if the number of items is too large
      *                         to provide a pleasant animation.
      */
     bool animateChangedItemCount(int changedItemCount) const;
 
     /**
      * @return True if a scrollbar for the given scroll-orientation is required
      *         when using a size of \p size for the view. Calling the method is rather
      *         expansive as a temporary relayout needs to be done.
      */
     bool scrollBarRequired(const QSizeF& size) const;
 
     /**
      * Shows a drop-indicator between items dependent on the given
      * cursor position. The cursor position is relative to the upper left
      * edge of the view.
      * @return Index of the item where the dropping is done. An index of -1
      *         indicates that the item has been dropped after the last item.
      */
     int showDropIndicator(const QPointF& pos);
     void hideDropIndicator();
 
     /**
      * Applies the height of the group header to the layouter. The height
      * depends on the used scroll orientation.
      */
     void updateGroupHeaderHeight();
 
     /**
      * Updates the siblings-information for all visible items that are inside
      * the range of \p firstIndex and \p lastIndex. If firstIndex or lastIndex
      * is smaller than 0, the siblings-information for all visible items gets
      * updated.
      * @see KItemListWidget::setSiblingsInformation()
      */
     void updateSiblingsInformation(int firstIndex = -1, int lastIndex = -1);
 
     /**
      * Helper method for updateExpansionIndicators().
      * @return True if the item with the index \a index has a sibling successor
      *         (= the item is not the last item of the current hierarchy).
      */
     bool hasSiblingSuccessor(int index) const;
 
     /**
      * Helper method for slotRoleEditingCanceled() and slotRoleEditingFinished().
      * Disconnects the two Signals "roleEditingCanceled" and
      * "roleEditingFinished"
      */
     void disconnectRoleEditingSignals(int index);
 
     /**
      * Helper function for triggerAutoScrolling().
      * @param pos    Logical position of the mouse relative to the range.
      * @param range  Range of the visible area.
      * @param oldInc Previous increment. Is used to assure that the increment
      *               increases only gradually.
      * @return Scroll increment that should be added to the offset().
      *         As soon as \a pos is inside the autoscroll-margin a
      *         value != 0 will be returned.
      */
     static int calculateAutoScrollingIncrement(int pos, int range, int oldInc);
 
     /**
      * Helper functions for changesItemCount().
      * @return The number of items that fit into the available size by
      *         respecting the size of the item and the margin between the items.
      */
     static int itemsPerSize(qreal size, qreal itemSize, qreal itemMargin);
 
 private:
     bool m_enabledSelectionToggles;
     bool m_grouped;
     bool m_supportsItemExpanding;
     bool m_editingRole;
     int m_activeTransactions; // Counter for beginTransaction()/endTransaction()
     LayoutAnimationHint m_endTransactionAnimationHint;
 
     QSizeF m_itemSize;
     KItemListController* m_controller;
     KItemModelBase* m_model;
     QList<QByteArray> m_visibleRoles;
     mutable KItemListWidgetCreatorBase* m_widgetCreator;
     mutable KItemListGroupHeaderCreatorBase* m_groupHeaderCreator;
     KItemListStyleOption m_styleOption;
 
     QHash<int, KItemListWidget*> m_visibleItems;
     QHash<KItemListWidget*, KItemListGroupHeader*> m_visibleGroups;
 
     struct Cell
     {
         Cell() : column(-1), row(-1) {}
         Cell(int c, int r) : column(c), row(r) {}
         int column;
         int row;
     };
     QHash<int, Cell> m_visibleCells;
 
     int m_scrollBarExtent;
     KItemListSizeHintResolver* m_sizeHintResolver;
     KItemListViewLayouter* m_layouter;
     KItemListViewAnimation* m_animation;
 
     QTimer* m_layoutTimer; // Triggers an asynchronous doLayout() call.
     qreal m_oldScrollOffset;
     qreal m_oldMaximumScrollOffset;
     qreal m_oldItemOffset;
     qreal m_oldMaximumItemOffset;
 
     bool m_skipAutoScrollForRubberBand;
     KItemListRubberBand* m_rubberBand;
 
     QPointF m_mousePos;
     int m_autoScrollIncrement;
     QTimer* m_autoScrollTimer;
 
     KItemListHeader* m_header;
     KItemListHeaderWidget* m_headerWidget;
 
     // When dragging items into the view where the sort-role of the model
     // is empty, a visual indicator should be shown during dragging where
     // the dropping will happen. This indicator is specified by an index
     // of the item. -1 means that no indicator will be shown at all.
     // The m_dropIndicator is set by the KItemListController
     // by KItemListView::showDropIndicator() and KItemListView::hideDropIndicator().
     QRectF m_dropIndicator;
 
     friend class KItemListContainer; // Accesses scrollBarRequired()
     friend class KItemListHeader;    // Accesses m_headerWidget
     friend class KItemListController;
     friend class KItemListControllerTest;
     friend class KItemListViewAccessible;
     friend class KItemListAccessibleCell;
 };
 
 /**
  * Allows to do a fast logical creation and deletion of QGraphicsWidgets
  * by recycling existing QGraphicsWidgets instances. Is used by
  * KItemListWidgetCreatorBase and KItemListGroupHeaderCreatorBase.
  * @internal
  */
 class DOLPHIN_EXPORT KItemListCreatorBase
 {
 public:
     virtual ~KItemListCreatorBase();
 
 protected:
     void addCreatedWidget(QGraphicsWidget* widget);
     void pushRecycleableWidget(QGraphicsWidget* widget);
     QGraphicsWidget* popRecycleableWidget();
 
 private:
     QSet<QGraphicsWidget*> m_createdWidgets;
     QList<QGraphicsWidget*> m_recycleableWidgets;
 };
 
 /**
  * @brief Base class for creating KItemListWidgets.
  *
  * It is recommended that applications simply use the KItemListWidgetCreator-template class.
  * For a custom implementation the methods create(), itemSizeHint() and preferredColumnWith()
  * must be reimplemented. The intention of the widget creator is to prevent repetitive and
  * expensive instantiations and deletions of KItemListWidgets by recycling existing widget
  * instances.
  */
 class DOLPHIN_EXPORT KItemListWidgetCreatorBase : public KItemListCreatorBase
 {
 public:
     virtual ~KItemListWidgetCreatorBase();
 
     virtual KItemListWidget* create(KItemListView* view) = 0;
 
     virtual void recycle(KItemListWidget* widget);
 
     virtual void calculateItemSizeHints(QVector<qreal>& logicalHeightHints, qreal& logicalWidthHint, const KItemListView* view) const = 0;
 
     virtual qreal preferredRoleColumnWidth(const QByteArray& role,
                                            int index,
                                            const KItemListView* view) const = 0;
 };
 
 /**
  * @brief Template class for creating KItemListWidgets.
  */
 template <class T>
 class KItemListWidgetCreator : public KItemListWidgetCreatorBase
 {
 public:
     KItemListWidgetCreator();
     virtual ~KItemListWidgetCreator();
 
     virtual KItemListWidget* create(KItemListView* view) Q_DECL_OVERRIDE;
 
     virtual void calculateItemSizeHints(QVector<qreal>& logicalHeightHints, qreal& logicalWidthHint, const KItemListView* view) const Q_DECL_OVERRIDE;
 
     virtual qreal preferredRoleColumnWidth(const QByteArray& role,
                                            int index,
                                            const KItemListView* view) const Q_DECL_OVERRIDE;
 private:
     KItemListWidgetInformant* m_informant;
 };
 
 template <class T>
 KItemListWidgetCreator<T>::KItemListWidgetCreator() :
     m_informant(T::createInformant())
 {
 }
 
 template <class T>
 KItemListWidgetCreator<T>::~KItemListWidgetCreator()
 {
     delete m_informant;
 }
 
 template <class T>
 KItemListWidget* KItemListWidgetCreator<T>::create(KItemListView* view)
 {
     KItemListWidget* widget = static_cast<KItemListWidget*>(popRecycleableWidget());
     if (!widget) {
         widget = new T(m_informant, view);
         addCreatedWidget(widget);
     }
     return widget;
 }
 
 template<class T>
 void KItemListWidgetCreator<T>::calculateItemSizeHints(QVector<qreal>& logicalHeightHints, qreal& logicalWidthHint, const KItemListView* view) const
 {
     return m_informant->calculateItemSizeHints(logicalHeightHints, logicalWidthHint, view);
 }
 
 template<class T>
 qreal KItemListWidgetCreator<T>::preferredRoleColumnWidth(const QByteArray& role,
                                                           int index,
                                                           const KItemListView* view) const
 {
     return m_informant->preferredRoleColumnWidth(role, index, view);
 }
 
 /**
  * @brief Base class for creating KItemListGroupHeaders.
  *
  * It is recommended that applications simply use the KItemListGroupHeaderCreator-template class.
  * For a custom implementation the methods create() and recyle() must be reimplemented.
  * The intention of the group-header creator is to prevent repetitive and expensive instantiations and
  * deletions of KItemListGroupHeaders by recycling existing header instances.
  */
 class DOLPHIN_EXPORT KItemListGroupHeaderCreatorBase : public KItemListCreatorBase
 {
 public:
     virtual ~KItemListGroupHeaderCreatorBase();
     virtual KItemListGroupHeader* create(KItemListView* view) = 0;
     virtual void recycle(KItemListGroupHeader* header);
 };
 
 template <class T>
 class KItemListGroupHeaderCreator : public KItemListGroupHeaderCreatorBase
 {
 public:
     virtual ~KItemListGroupHeaderCreator();
     virtual KItemListGroupHeader* create(KItemListView* view) Q_DECL_OVERRIDE;
 };
 
 template <class T>
 KItemListGroupHeaderCreator<T>::~KItemListGroupHeaderCreator()
 {
 }
 
 template <class T>
 KItemListGroupHeader* KItemListGroupHeaderCreator<T>::create(KItemListView* view)
 {
     KItemListGroupHeader* widget = static_cast<KItemListGroupHeader*>(popRecycleableWidget());
     if (!widget) {
         widget = new T(view);
         addCreatedWidget(widget);
     }
     return widget;
 }
 
 #endif
diff --git a/src/views/dolphinview.cpp b/src/views/dolphinview.cpp
index 2ca51f52d..4485c1707 100644
--- a/src/views/dolphinview.cpp
+++ b/src/views/dolphinview.cpp
@@ -1,1765 +1,1806 @@
 /***************************************************************************
  *   Copyright (C) 2006-2009 by Peter Penz <peter.penz19@gmail.com>        *
  *   Copyright (C) 2006 by Gregor Kališnik <gregor@podnapisi.net>          *
  *                                                                         *
  *   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 "dolphinview.h"
 
 #include <config-baloo.h>
 
 #include <QAbstractItemView>
 #include <QApplication>
 #include <QClipboard>
 #include <QDropEvent>
 #include <QGraphicsSceneDragDropEvent>
 #include <QTimer>
 #include <QScrollBar>
 #include <QPixmapCache>
 #include <QPointer>
 #include <QMenu>
 #include <QVBoxLayout>
 #include <KDesktopFile>
 #include <KProtocolManager>
 #include <KColorScheme>
 #include <KDirModel>
 #include <KFileItem>
 #include <KFileItemListProperties>
 #include <KLocalizedString>
 #include <kitemviews/kfileitemmodel.h>
 #include <kitemviews/kfileitemlistview.h>
 #include <kitemviews/kitemlistcontainer.h>
 #include <kitemviews/kitemlistheader.h>
 #include <kitemviews/kitemlistselectionmanager.h>
 #include <kitemviews/kitemlistview.h>
 #include <kitemviews/kitemlistcontroller.h>
 #include <KIO/CopyJob>
 #include <KIO/DeleteJob>
 #include <KIO/JobUiDelegate>
 #include <KIO/PreviewJob>
 #include <KIO/DropJob>
 #include <KIO/PasteJob>
 #include <KIO/Paste>
 #include <KJob>
 #include <KMessageBox>
 #include <KJobWidgets>
 #include <QUrl>
 
 #include "dolphinnewfilemenuobserver.h"
 #include "dolphin_detailsmodesettings.h"
 #include "dolphin_generalsettings.h"
 #include "dolphinitemlistview.h"
 #include "draganddrophelper.h"
 #include "renamedialog.h"
 #include "versioncontrol/versioncontrolobserver.h"
 #include "viewmodecontroller.h"
 #include "viewproperties.h"
 #include "views/tooltips/tooltipmanager.h"
 #include "zoomlevelinfo.h"
 
 #ifdef HAVE_BALOO
     #include <Baloo/IndexerConfig>
 #endif
 #include <KFormat>
 
 DolphinView::DolphinView(const QUrl& url, QWidget* parent) :
     QWidget(parent),
     m_active(true),
     m_tabsForFiles(false),
     m_assureVisibleCurrentIndex(false),
     m_isFolderWritable(true),
     m_dragging(false),
     m_url(url),
     m_viewPropertiesContext(),
     m_mode(DolphinView::IconsView),
     m_visibleRoles(),
     m_topLayout(0),
     m_model(0),
     m_view(0),
     m_container(0),
     m_toolTipManager(0),
     m_selectionChangedTimer(0),
     m_currentItemUrl(),
     m_scrollToCurrentItem(false),
     m_restoredContentsPosition(),
     m_selectedUrls(),
     m_clearSelectionBeforeSelectingNewItems(false),
     m_markFirstNewlySelectedItemAsCurrent(false),
-    m_versionControlObserver(0)
+    m_versionControlObserver(0),
+    m_twoClicksRenamingTimer(nullptr)
 {
     m_topLayout = new QVBoxLayout(this);
     m_topLayout->setSpacing(0);
     m_topLayout->setMargin(0);
 
     // When a new item has been created by the "Create New..." menu, the item should
     // get selected and it must be assured that the item will get visible. As the
     // creation is done asynchronously, several signals must be checked:
     connect(&DolphinNewFileMenuObserver::instance(), &DolphinNewFileMenuObserver::itemCreated,
             this, &DolphinView::observeCreatedItem);
 
     m_selectionChangedTimer = new QTimer(this);
     m_selectionChangedTimer->setSingleShot(true);
     m_selectionChangedTimer->setInterval(300);
     connect(m_selectionChangedTimer, &QTimer::timeout,
             this, &DolphinView::emitSelectionChangedSignal);
 
     m_model = new KFileItemModel(this);
     m_view = new DolphinItemListView();
     m_view->setEnabledSelectionToggles(GeneralSettings::showSelectionToggle());
     m_view->setVisibleRoles({"text"});
     applyModeToView();
 
     KItemListController* controller = new KItemListController(m_model, m_view, this);
     const int delay = GeneralSettings::autoExpandFolders() ? 750 : -1;
     controller->setAutoActivationDelay(delay);
 
     // The EnlargeSmallPreviews setting can only be changed after the model
     // has been set in the view by KItemListController.
     m_view->setEnlargeSmallPreviews(GeneralSettings::enlargeSmallPreviews());
 
     m_container = new KItemListContainer(controller, this);
     m_container->installEventFilter(this);
     setFocusProxy(m_container);
     connect(m_container->horizontalScrollBar(), &QScrollBar::valueChanged, this, &DolphinView::hideToolTip);
     connect(m_container->verticalScrollBar(), &QScrollBar::valueChanged, this, &DolphinView::hideToolTip);
 
     controller->setSelectionBehavior(KItemListController::MultiSelection);
     connect(controller, &KItemListController::itemActivated, this, &DolphinView::slotItemActivated);
     connect(controller, &KItemListController::itemsActivated, this, &DolphinView::slotItemsActivated);
     connect(controller, &KItemListController::itemMiddleClicked, this, &DolphinView::slotItemMiddleClicked);
     connect(controller, &KItemListController::itemContextMenuRequested, this, &DolphinView::slotItemContextMenuRequested);
     connect(controller, &KItemListController::viewContextMenuRequested, this, &DolphinView::slotViewContextMenuRequested);
     connect(controller, &KItemListController::headerContextMenuRequested, this, &DolphinView::slotHeaderContextMenuRequested);
     connect(controller, &KItemListController::mouseButtonPressed, this, &DolphinView::slotMouseButtonPressed);
     connect(controller, &KItemListController::itemHovered, this, &DolphinView::slotItemHovered);
     connect(controller, &KItemListController::itemUnhovered, this, &DolphinView::slotItemUnhovered);
     connect(controller, &KItemListController::itemDropEvent, this, &DolphinView::slotItemDropEvent);
     connect(controller, &KItemListController::escapePressed, this, &DolphinView::stopLoading);
     connect(controller, &KItemListController::modelChanged, this, &DolphinView::slotModelChanged);
+    connect(controller, &KItemListController::selectedItemTextPressed, this, &DolphinView::slotSelectedItemTextPressed);
 
     connect(m_model, &KFileItemModel::directoryLoadingStarted,       this, &DolphinView::slotDirectoryLoadingStarted);
     connect(m_model, &KFileItemModel::directoryLoadingCompleted,     this, &DolphinView::slotDirectoryLoadingCompleted);
     connect(m_model, &KFileItemModel::directoryLoadingCanceled,      this, &DolphinView::directoryLoadingCanceled);
     connect(m_model, &KFileItemModel::directoryLoadingProgress,   this, &DolphinView::directoryLoadingProgress);
     connect(m_model, &KFileItemModel::directorySortingProgress,   this, &DolphinView::directorySortingProgress);
     connect(m_model, &KFileItemModel::itemsChanged,
             this, &DolphinView::slotItemsChanged);
     connect(m_model, &KFileItemModel::itemsRemoved,    this, &DolphinView::itemCountChanged);
     connect(m_model, &KFileItemModel::itemsInserted,   this, &DolphinView::itemCountChanged);
     connect(m_model, &KFileItemModel::infoMessage,            this, &DolphinView::infoMessage);
     connect(m_model, &KFileItemModel::errorMessage,           this, &DolphinView::errorMessage);
     connect(m_model, &KFileItemModel::directoryRedirection, this, &DolphinView::slotDirectoryRedirection);
     connect(m_model, &KFileItemModel::urlIsFileError,            this, &DolphinView::urlIsFileError);
 
     m_view->installEventFilter(this);
     connect(m_view, &DolphinItemListView::sortOrderChanged,
             this, &DolphinView::slotSortOrderChangedByHeader);
     connect(m_view, &DolphinItemListView::sortRoleChanged,
             this, &DolphinView::slotSortRoleChangedByHeader);
     connect(m_view, &DolphinItemListView::visibleRolesChanged,
             this, &DolphinView::slotVisibleRolesChangedByHeader);
     connect(m_view, &DolphinItemListView::roleEditingCanceled,
             this, &DolphinView::slotRoleEditingCanceled);
     connect(m_view->header(), &KItemListHeader::columnWidthChangeFinished,
             this, &DolphinView::slotHeaderColumnWidthChangeFinished);
 
     KItemListSelectionManager* selectionManager = controller->selectionManager();
     connect(selectionManager, &KItemListSelectionManager::selectionChanged,
             this, &DolphinView::slotSelectionChanged);
 
     m_toolTipManager = new ToolTipManager(this);
     connect(m_toolTipManager, &ToolTipManager::urlActivated, this, &DolphinView::urlActivated);
 
     m_versionControlObserver = new VersionControlObserver(this);
     m_versionControlObserver->setModel(m_model);
     connect(m_versionControlObserver, &VersionControlObserver::infoMessage, this, &DolphinView::infoMessage);
     connect(m_versionControlObserver, &VersionControlObserver::errorMessage, this, &DolphinView::errorMessage);
     connect(m_versionControlObserver, &VersionControlObserver::operationCompletedMessage, this, &DolphinView::operationCompletedMessage);
 
+    m_twoClicksRenamingTimer = new QTimer(this);
+    m_twoClicksRenamingTimer->setSingleShot(true);
+    connect(m_twoClicksRenamingTimer, &QTimer::timeout, this, &DolphinView::slotTwoClicksRenamingTimerTimeout);
+
     applyViewProperties();
     m_topLayout->addWidget(m_container);
 
     loadDirectory(url);
 }
 
 DolphinView::~DolphinView()
 {
 }
 
 QUrl DolphinView::url() const
 {
     return m_url;
 }
 
 void DolphinView::setActive(bool active)
 {
     if (active == m_active) {
         return;
     }
 
     m_active = active;
 
     updatePalette();
 
     if (active) {
         m_container->setFocus();
         emit activated();
         emit writeStateChanged(m_isFolderWritable);
     }
 }
 
 bool DolphinView::isActive() const
 {
     return m_active;
 }
 
 void DolphinView::setMode(Mode mode)
 {
     if (mode != m_mode) {
         ViewProperties props(viewPropertiesUrl());
         props.setViewMode(mode);
 
         // We pass the new ViewProperties to applyViewProperties, rather than
         // storing them on disk and letting applyViewProperties() read them
         // from there, to prevent that changing the view mode fails if the
         // .directory file is not writable (see bug 318534).
         applyViewProperties(props);
     }
 }
 
 DolphinView::Mode DolphinView::mode() const
 {
     return m_mode;
 }
 
 void DolphinView::setPreviewsShown(bool show)
 {
     if (previewsShown() == show) {
         return;
     }
 
     ViewProperties props(viewPropertiesUrl());
     props.setPreviewsShown(show);
 
     const int oldZoomLevel = m_view->zoomLevel();
     m_view->setPreviewsShown(show);
     emit previewsShownChanged(show);
 
     const int newZoomLevel = m_view->zoomLevel();
     if (newZoomLevel != oldZoomLevel) {
         emit zoomLevelChanged(newZoomLevel, oldZoomLevel);
     }
 }
 
 bool DolphinView::previewsShown() const
 {
     return m_view->previewsShown();
 }
 
 void DolphinView::setHiddenFilesShown(bool show)
 {
     if (m_model->showHiddenFiles() == show) {
         return;
     }
 
     const KFileItemList itemList = selectedItems();
     m_selectedUrls.clear();
     m_selectedUrls = itemList.urlList();
 
     ViewProperties props(viewPropertiesUrl());
     props.setHiddenFilesShown(show);
 
     m_model->setShowHiddenFiles(show);
     emit hiddenFilesShownChanged(show);
 }
 
 bool DolphinView::hiddenFilesShown() const
 {
     return m_model->showHiddenFiles();
 }
 
 void DolphinView::setGroupedSorting(bool grouped)
 {
     if (grouped == groupedSorting()) {
         return;
     }
 
     ViewProperties props(viewPropertiesUrl());
     props.setGroupedSorting(grouped);
     props.save();
 
     m_container->controller()->model()->setGroupedSorting(grouped);
 
     emit groupedSortingChanged(grouped);
 }
 
 bool DolphinView::groupedSorting() const
 {
     return m_model->groupedSorting();
 }
 
 KFileItemList DolphinView::items() const
 {
     KFileItemList list;
     const int itemCount = m_model->count();
     list.reserve(itemCount);
 
     for (int i = 0; i < itemCount; ++i) {
         list.append(m_model->fileItem(i));
     }
 
     return list;
 }
 
 int DolphinView::itemsCount() const
 {
     return m_model->count();
 }
 
 KFileItemList DolphinView::selectedItems() const
 {
     const KItemListSelectionManager* selectionManager = m_container->controller()->selectionManager();
 
     KFileItemList selectedItems;
     const auto items = selectionManager->selectedItems();
     selectedItems.reserve(items.count());
     for (int index : items) {
         selectedItems.append(m_model->fileItem(index));
     }
     return selectedItems;
 }
 
 int DolphinView::selectedItemsCount() const
 {
     const KItemListSelectionManager* selectionManager = m_container->controller()->selectionManager();
     return selectionManager->selectedItems().count();
 }
 
 void DolphinView::markUrlsAsSelected(const QList<QUrl>& urls)
 {
     m_selectedUrls = urls;
 }
 
 void DolphinView::markUrlAsCurrent(const QUrl &url)
 {
     m_currentItemUrl = url;
     m_scrollToCurrentItem = true;
 }
 
 void DolphinView::selectItems(const QRegExp& pattern, bool enabled)
 {
     const KItemListSelectionManager::SelectionMode mode = enabled
                                                         ? KItemListSelectionManager::Select
                                                         : KItemListSelectionManager::Deselect;
     KItemListSelectionManager* selectionManager = m_container->controller()->selectionManager();
 
     for (int index = 0; index < m_model->count(); index++) {
         const KFileItem item = m_model->fileItem(index);
         if (pattern.exactMatch(item.text())) {
             // An alternative approach would be to store the matching items in a KItemSet and
             // select them in one go after the loop, but we'd need a new function
             // KItemListSelectionManager::setSelected(KItemSet, SelectionMode mode)
             // for that.
             selectionManager->setSelected(index, 1, mode);
         }
     }
 }
 
 void DolphinView::setZoomLevel(int level)
 {
     const int oldZoomLevel = zoomLevel();
     m_view->setZoomLevel(level);
     if (zoomLevel() != oldZoomLevel) {
         hideToolTip();
         emit zoomLevelChanged(zoomLevel(), oldZoomLevel);
     }
 }
 
 int DolphinView::zoomLevel() const
 {
     return m_view->zoomLevel();
 }
 
 void DolphinView::setSortRole(const QByteArray& role)
 {
     if (role != sortRole()) {
         updateSortRole(role);
     }
 }
 
 QByteArray DolphinView::sortRole() const
 {
     const KItemModelBase* model = m_container->controller()->model();
     return model->sortRole();
 }
 
 void DolphinView::setSortOrder(Qt::SortOrder order)
 {
     if (sortOrder() != order) {
         updateSortOrder(order);
     }
 }
 
 Qt::SortOrder DolphinView::sortOrder() const
 {
     return m_model->sortOrder();
 }
 
 void DolphinView::setSortFoldersFirst(bool foldersFirst)
 {
     if (sortFoldersFirst() != foldersFirst) {
         updateSortFoldersFirst(foldersFirst);
     }
 }
 
 bool DolphinView::sortFoldersFirst() const
 {
     return m_model->sortDirectoriesFirst();
 }
 
 void DolphinView::setVisibleRoles(const QList<QByteArray>& roles)
 {
     const QList<QByteArray> previousRoles = roles;
 
     ViewProperties props(viewPropertiesUrl());
     props.setVisibleRoles(roles);
 
     m_visibleRoles = roles;
     m_view->setVisibleRoles(roles);
 
     emit visibleRolesChanged(m_visibleRoles, previousRoles);
 }
 
 QList<QByteArray> DolphinView::visibleRoles() const
 {
     return m_visibleRoles;
 }
 
 void DolphinView::reload()
 {
     QByteArray viewState;
     QDataStream saveStream(&viewState, QIODevice::WriteOnly);
     saveState(saveStream);
 
     setUrl(url());
     loadDirectory(url(), true);
 
     QDataStream restoreStream(viewState);
     restoreState(restoreStream);
 }
 
 void DolphinView::readSettings()
 {
     const int oldZoomLevel = m_view->zoomLevel();
 
     GeneralSettings::self()->load();
     m_view->readSettings();
     applyViewProperties();
 
     const int delay = GeneralSettings::autoExpandFolders() ? 750 : -1;
     m_container->controller()->setAutoActivationDelay(delay);
 
     const int newZoomLevel = m_view->zoomLevel();
     if (newZoomLevel != oldZoomLevel) {
         emit zoomLevelChanged(newZoomLevel, oldZoomLevel);
     }
 }
 
 void DolphinView::writeSettings()
 {
     GeneralSettings::self()->save();
     m_view->writeSettings();
 }
 
 void DolphinView::setNameFilter(const QString& nameFilter)
 {
     m_model->setNameFilter(nameFilter);
 }
 
 QString DolphinView::nameFilter() const
 {
     return m_model->nameFilter();
 }
 
 void DolphinView::setMimeTypeFilters(const QStringList& filters)
 {
     return m_model->setMimeTypeFilters(filters);
 }
 
 QStringList DolphinView::mimeTypeFilters() const
 {
     return m_model->mimeTypeFilters();
 }
 
 QString DolphinView::statusBarText() const
 {
     QString summary;
     QString foldersText;
     QString filesText;
 
     int folderCount = 0;
     int fileCount = 0;
     KIO::filesize_t totalFileSize = 0;
 
     if (m_container->controller()->selectionManager()->hasSelection()) {
         // Give a summary of the status of the selected files
         const KFileItemList list = selectedItems();
         foreach (const KFileItem& item, list) {
             if (item.isDir()) {
                 ++folderCount;
             } else {
                 ++fileCount;
                 totalFileSize += item.size();
             }
         }
 
         if (folderCount + fileCount == 1) {
             // If only one item is selected, show info about it
             return list.first().getStatusBarInfo();
         } else {
             // At least 2 items are selected
             foldersText = i18ncp("@info:status", "1 Folder selected", "%1 Folders selected", folderCount);
             filesText = i18ncp("@info:status", "1 File selected", "%1 Files selected", fileCount);
         }
     } else {
         calculateItemCount(fileCount, folderCount, totalFileSize);
         foldersText = i18ncp("@info:status", "1 Folder", "%1 Folders", folderCount);
         filesText = i18ncp("@info:status", "1 File", "%1 Files", fileCount);
     }
 
     if (fileCount > 0 && folderCount > 0) {
         summary = i18nc("@info:status folders, files (size)", "%1, %2 (%3)",
                         foldersText, filesText,
                         KFormat().formatByteSize(totalFileSize));
     } else if (fileCount > 0) {
         summary = i18nc("@info:status files (size)", "%1 (%2)",
                         filesText,
                         KFormat().formatByteSize(totalFileSize));
     } else if (folderCount > 0) {
         summary = foldersText;
     } else {
         summary = i18nc("@info:status", "0 Folders, 0 Files");
     }
 
     return summary;
 }
 
 QList<QAction*> DolphinView::versionControlActions(const KFileItemList& items) const
 {
     QList<QAction*> actions;
 
     if (items.isEmpty()) {
         const KFileItem item = m_model->rootItem();
         if (!item.isNull()) {
             actions = m_versionControlObserver->actions(KFileItemList() << item);
         }
     } else {
         actions = m_versionControlObserver->actions(items);
     }
 
     return actions;
 }
 
 void DolphinView::setUrl(const QUrl& url)
 {
     if (url == m_url) {
         return;
     }
 
     clearSelection();
 
     m_url = url;
 
     hideToolTip();
 
     disconnect(m_view, &DolphinItemListView::roleEditingFinished,
                this, &DolphinView::slotRoleEditingFinished);
 
     // It is important to clear the items from the model before
     // applying the view properties, otherwise expensive operations
     // might be done on the existing items although they get cleared
     // anyhow afterwards by loadDirectory().
     m_model->clear();
     applyViewProperties();
     loadDirectory(url);
 
     emit urlChanged(url);
 }
 
 void DolphinView::selectAll()
 {
     KItemListSelectionManager* selectionManager = m_container->controller()->selectionManager();
     selectionManager->setSelected(0, m_model->count());
 }
 
 void DolphinView::invertSelection()
 {
     KItemListSelectionManager* selectionManager = m_container->controller()->selectionManager();
     selectionManager->setSelected(0, m_model->count(), KItemListSelectionManager::Toggle);
 }
 
 void DolphinView::clearSelection()
 {
     m_selectedUrls.clear();
     m_container->controller()->selectionManager()->clearSelection();
 }
 
 void DolphinView::renameSelectedItems()
 {
     const KFileItemList items = selectedItems();
     if (items.isEmpty()) {
         return;
     }
 
     if (items.count() == 1 && GeneralSettings::renameInline()) {
         const int index = m_model->index(items.first());
         m_view->editRole(index, "text");
 
         hideToolTip();
 
         connect(m_view, &DolphinItemListView::roleEditingFinished,
                 this, &DolphinView::slotRoleEditingFinished);
     } else {
         RenameDialog* dialog = new RenameDialog(this, items);
 
         connect(dialog, &RenameDialog::renamingFinished, this, &DolphinView::slotRenameDialogRenamingFinished);
 
         dialog->setAttribute(Qt::WA_DeleteOnClose);
         dialog->show();
         dialog->raise();
         dialog->activateWindow();
     }
 
     // Assure that the current index remains visible when KFileItemModel
     // will notify the view about changed items (which might result in
     // a changed sorting).
     m_assureVisibleCurrentIndex = true;
 }
 
 void DolphinView::trashSelectedItems()
 {
     const QList<QUrl> list = simplifiedSelectedUrls();
     KIO::JobUiDelegate uiDelegate;
     uiDelegate.setWindow(window());
     if (uiDelegate.askDeleteConfirmation(list, KIO::JobUiDelegate::Trash, KIO::JobUiDelegate::DefaultConfirmation)) {
         KIO::Job* job = KIO::trash(list);
         KIO::FileUndoManager::self()->recordJob(KIO::FileUndoManager::Trash, list, QUrl(QStringLiteral("trash:/")), job);
         KJobWidgets::setWindow(job, this);
         connect(job, &KIO::Job::result,
                 this, &DolphinView::slotTrashFileFinished);
     }
 }
 
 void DolphinView::deleteSelectedItems()
 {
     const QList<QUrl> list = simplifiedSelectedUrls();
 
     KIO::JobUiDelegate uiDelegate;
     uiDelegate.setWindow(window());
     if (uiDelegate.askDeleteConfirmation(list, KIO::JobUiDelegate::Delete, KIO::JobUiDelegate::DefaultConfirmation)) {
         KIO::Job* job = KIO::del(list);
         KJobWidgets::setWindow(job, this);
         connect(job, &KIO::Job::result,
                 this, &DolphinView::slotDeleteFileFinished);
     }
 }
 
 void DolphinView::cutSelectedItems()
 {
     QMimeData* mimeData = selectionMimeData();
     KIO::setClipboardDataCut(mimeData, true);
     QApplication::clipboard()->setMimeData(mimeData);
 }
 
 void DolphinView::copySelectedItems()
 {
     QMimeData* mimeData = selectionMimeData();
     QApplication::clipboard()->setMimeData(mimeData);
 }
 
 void DolphinView::paste()
 {
     pasteToUrl(url());
 }
 
 void DolphinView::pasteIntoFolder()
 {
     const KFileItemList items = selectedItems();
     if ((items.count() == 1) && items.first().isDir()) {
         pasteToUrl(items.first().url());
     }
 }
 
 void DolphinView::stopLoading()
 {
     m_model->cancelDirectoryLoading();
 }
 
 void DolphinView::updatePalette()
 {
     QColor color = KColorScheme(QPalette::Active, KColorScheme::View).background().color();
     if (!m_active) {
         color.setAlpha(150);
     }
 
     QWidget* viewport = m_container->viewport();
     if (viewport) {
         QPalette palette;
         palette.setColor(viewport->backgroundRole(), color);
         viewport->setPalette(palette);
     }
 
     update();
 }
 
+void DolphinView::abortTwoClicksRenaming()
+{
+    m_twoClicksRenamingItemUrl.clear();
+    m_twoClicksRenamingTimer->stop();
+}
+
 bool DolphinView::eventFilter(QObject* watched, QEvent* event)
 {
     switch (event->type()) {
     case QEvent::PaletteChange:
         updatePalette();
         QPixmapCache::clear();
         break;
 
     case QEvent::KeyPress:
         if (GeneralSettings::useTabForSwitchingSplitView()) {
             QKeyEvent* keyEvent = static_cast<QKeyEvent*>(event);
             if (keyEvent->key() == Qt::Key_Tab && keyEvent->modifiers() == Qt::NoModifier) {
                 emit toggleActiveViewRequested();
                 return true;
             }
         }
         break;
     case QEvent::FocusIn:
         if (watched == m_container) {
             setActive(true);
         }
         break;
 
     case QEvent::GraphicsSceneDragEnter:
         if (watched == m_view) {
             m_dragging = true;
         }
         break;
 
     case QEvent::GraphicsSceneDragLeave:
         if (watched == m_view) {
             m_dragging = false;
         }
         break;
 
     case QEvent::GraphicsSceneDrop:
         if (watched == m_view) {
             m_dragging = false;
         }
     default:
         break;
     }
 
     return QWidget::eventFilter(watched, event);
 }
 
 void DolphinView::wheelEvent(QWheelEvent* event)
 {
     if (event->modifiers().testFlag(Qt::ControlModifier)) {
         const int numDegrees = event->delta() / 8;
         const int numSteps = numDegrees / 15;
 
         setZoomLevel(zoomLevel() + numSteps);
         event->accept();
     } else {
         event->ignore();
     }
 }
 
 void DolphinView::hideEvent(QHideEvent* event)
 {
     hideToolTip();
     QWidget::hideEvent(event);
 }
 
 bool DolphinView::event(QEvent* event)
 {
-    /* See Bug 297355
-     * Dolphin leaves file preview tooltips open even when is not visible.
-     *
-     * Hide tool-tip when Dolphin loses focus.
-     */
     if (event->type() == QEvent::WindowDeactivate) {
+        /* See Bug 297355
+         * Dolphin leaves file preview tooltips open even when is not visible.
+         *
+         * Hide tool-tip when Dolphin loses focus.
+         */
         hideToolTip();
+        abortTwoClicksRenaming();
     }
 
     return QWidget::event(event);
 }
 
 void DolphinView::activate()
 {
     setActive(true);
 }
 
 void DolphinView::slotItemActivated(int index)
 {
+    abortTwoClicksRenaming();
+
     const KFileItem item = m_model->fileItem(index);
     if (!item.isNull()) {
         emit itemActivated(item);
     }
 }
 
 void DolphinView::slotItemsActivated(const KItemSet& indexes)
 {
     Q_ASSERT(indexes.count() >= 2);
 
+    abortTwoClicksRenaming();
+
     if (indexes.count() > 5) {
         QString question = i18np("Are you sure you want to open 1 item?", "Are you sure you want to open %1 items?", indexes.count());
         const int answer = KMessageBox::warningYesNo(this, question);
         if (answer != KMessageBox::Yes) {
             return;
         }
     }
 
     KFileItemList items;
     items.reserve(indexes.count());
 
     for (int index : indexes) {
         KFileItem item = m_model->fileItem(index);
         const QUrl& url = openItemAsFolderUrl(item);
 
         if (!url.isEmpty()) { // Open folders in new tabs
             emit tabRequested(url);
         } else {
             items.append(item);
         }
     }
 
     if (items.count() == 1) {
         emit itemActivated(items.first());
     } else if (items.count() > 1) {
         emit itemsActivated(items);
     }
 }
 
 void DolphinView::slotItemMiddleClicked(int index)
 {
     const KFileItem& item = m_model->fileItem(index);
     const QUrl& url = openItemAsFolderUrl(item);
     if (!url.isEmpty()) {
         emit tabRequested(url);
     } else if (isTabsForFilesEnabled()) {
         emit tabRequested(item.url());
     }
 }
 
 void DolphinView::slotItemContextMenuRequested(int index, const QPointF& pos)
 {
     // Force emit of a selection changed signal before we request the
     // context menu, to update the edit-actions first. (See Bug 294013)
     if (m_selectionChangedTimer->isActive()) {
         emitSelectionChangedSignal();
     }
 
     const KFileItem item = m_model->fileItem(index);
     emit requestContextMenu(pos.toPoint(), item, url(), QList<QAction*>());
 }
 
 void DolphinView::slotViewContextMenuRequested(const QPointF& pos)
 {
     emit requestContextMenu(pos.toPoint(), KFileItem(), url(), QList<QAction*>());
 }
 
 void DolphinView::slotHeaderContextMenuRequested(const QPointF& pos)
 {
     ViewProperties props(viewPropertiesUrl());
 
     QPointer<QMenu> menu = new QMenu(QApplication::activeWindow());
 
     KItemListView* view = m_container->controller()->view();
     const QSet<QByteArray> visibleRolesSet = view->visibleRoles().toSet();
 
     bool indexingEnabled = false;
 #ifdef HAVE_BALOO
     Baloo::IndexerConfig config;
     indexingEnabled = config.fileIndexingEnabled();
 #endif
 
     QString groupName;
     QMenu* groupMenu = 0;
 
     // Add all roles to the menu that can be shown or hidden by the user
     const QList<KFileItemModel::RoleInfo> rolesInfo = KFileItemModel::rolesInformation();
     foreach (const KFileItemModel::RoleInfo& info, rolesInfo) {
         if (info.role == "text") {
             // It should not be possible to hide the "text" role
             continue;
         }
 
         const QString text = m_model->roleDescription(info.role);
         QAction* action = 0;
         if (info.group.isEmpty()) {
             action = menu->addAction(text);
         } else {
             if (!groupMenu || info.group != groupName) {
                 groupName = info.group;
                 groupMenu = menu->addMenu(groupName);
             }
 
             action = groupMenu->addAction(text);
         }
 
         action->setCheckable(true);
         action->setChecked(visibleRolesSet.contains(info.role));
         action->setData(info.role);
 
         const bool enable = (!info.requiresBaloo && !info.requiresIndexer) ||
                             (info.requiresBaloo) ||
                             (info.requiresIndexer && indexingEnabled);
         action->setEnabled(enable);
     }
 
     menu->addSeparator();
 
     QActionGroup* widthsGroup = new QActionGroup(menu);
     const bool autoColumnWidths = props.headerColumnWidths().isEmpty();
 
     QAction* autoAdjustWidthsAction = menu->addAction(i18nc("@action:inmenu", "Automatic Column Widths"));
     autoAdjustWidthsAction->setCheckable(true);
     autoAdjustWidthsAction->setChecked(autoColumnWidths);
     autoAdjustWidthsAction->setActionGroup(widthsGroup);
 
     QAction* customWidthsAction = menu->addAction(i18nc("@action:inmenu", "Custom Column Widths"));
     customWidthsAction->setCheckable(true);
     customWidthsAction->setChecked(!autoColumnWidths);
     customWidthsAction->setActionGroup(widthsGroup);
 
     QAction* action = menu->exec(pos.toPoint());
     if (menu && action) {
         KItemListHeader* header = view->header();
 
         if (action == autoAdjustWidthsAction) {
             // Clear the column-widths from the viewproperties and turn on
             // the automatic resizing of the columns
             props.setHeaderColumnWidths(QList<int>());
             header->setAutomaticColumnResizing(true);
         } else if (action == customWidthsAction) {
             // Apply the current column-widths as custom column-widths and turn
             // off the automatic resizing of the columns
             QList<int> columnWidths;
             columnWidths.reserve(view->visibleRoles().count());
             foreach (const QByteArray& role, view->visibleRoles()) {
                 columnWidths.append(header->columnWidth(role));
             }
             props.setHeaderColumnWidths(columnWidths);
             header->setAutomaticColumnResizing(false);
         } else {
             // Show or hide the selected role
             const QByteArray selectedRole = action->data().toByteArray();
 
             QList<QByteArray> visibleRoles = view->visibleRoles();
             if (action->isChecked()) {
                 visibleRoles.append(selectedRole);
             } else {
                 visibleRoles.removeOne(selectedRole);
             }
 
             view->setVisibleRoles(visibleRoles);
             props.setVisibleRoles(visibleRoles);
 
             QList<int> columnWidths;
             if (!header->automaticColumnResizing()) {
                 columnWidths.reserve(view->visibleRoles().count());
                 foreach (const QByteArray& role, view->visibleRoles()) {
                     columnWidths.append(header->columnWidth(role));
                 }
             }
             props.setHeaderColumnWidths(columnWidths);
         }
     }
 
     delete menu;
 }
 
 void DolphinView::slotHeaderColumnWidthChangeFinished(const QByteArray& role, qreal current)
 {
     const QList<QByteArray> visibleRoles = m_view->visibleRoles();
 
     ViewProperties props(viewPropertiesUrl());
     QList<int> columnWidths = props.headerColumnWidths();
     if (columnWidths.count() != visibleRoles.count()) {
         columnWidths.clear();
         columnWidths.reserve(visibleRoles.count());
         const KItemListHeader* header = m_view->header();
         foreach (const QByteArray& role, visibleRoles) {
             const int width = header->columnWidth(role);
             columnWidths.append(width);
         }
     }
 
     const int roleIndex = visibleRoles.indexOf(role);
     Q_ASSERT(roleIndex >= 0 && roleIndex < columnWidths.count());
     columnWidths[roleIndex] = current;
 
     props.setHeaderColumnWidths(columnWidths);
 }
 
 void DolphinView::slotItemHovered(int index)
 {
     const KFileItem item = m_model->fileItem(index);
 
     if (GeneralSettings::showToolTips() && !m_dragging) {
         QRectF itemRect = m_container->controller()->view()->itemContextRect(index);
         const QPoint pos = m_container->mapToGlobal(itemRect.topLeft().toPoint());
         itemRect.moveTo(pos);
 
         m_toolTipManager->showToolTip(item, itemRect, nativeParentWidget()->windowHandle());
     }
 
     emit requestItemInfo(item);
 }
 
 void DolphinView::slotItemUnhovered(int index)
 {
     Q_UNUSED(index);
     hideToolTip();
     emit requestItemInfo(KFileItem());
 }
 
 void DolphinView::slotItemDropEvent(int index, QGraphicsSceneDragDropEvent* event)
 {
     QUrl destUrl;
     KFileItem destItem = m_model->fileItem(index);
     if (destItem.isNull() || (!destItem.isDir() && !destItem.isDesktopFile())) {
         // Use the URL of the view as drop target if the item is no directory
         // or desktop-file
         destItem = m_model->rootItem();
         destUrl = url();
     } else {
         // The item represents a directory or desktop-file
         destUrl = destItem.mostLocalUrl();
     }
 
     QDropEvent dropEvent(event->pos().toPoint(),
                          event->possibleActions(),
                          event->mimeData(),
                          event->buttons(),
                          event->modifiers());
     dropUrls(destUrl, &dropEvent, this);
 
     setActive(true);
 }
 
 void DolphinView::dropUrls(const QUrl &destUrl, QDropEvent *dropEvent, QWidget *dropWidget)
 {
     KIO::DropJob* job = DragAndDropHelper::dropUrls(destUrl, dropEvent, dropWidget);
 
     if (job) {
         connect(job, &KIO::DropJob::result, this, &DolphinView::slotPasteJobResult);
 
         if (destUrl == url()) {
             // Mark the dropped urls as selected.
             m_clearSelectionBeforeSelectingNewItems = true;
             m_markFirstNewlySelectedItemAsCurrent = true;
             connect(job, &KIO::DropJob::itemCreated, this, &DolphinView::slotItemCreated);
         }
     }
 }
 
 void DolphinView::slotModelChanged(KItemModelBase* current, KItemModelBase* previous)
 {
     if (previous != 0) {
         Q_ASSERT(qobject_cast<KFileItemModel*>(previous));
         KFileItemModel* fileItemModel = static_cast<KFileItemModel*>(previous);
         disconnect(fileItemModel, &KFileItemModel::directoryLoadingCompleted, this, &DolphinView::slotDirectoryLoadingCompleted);
         m_versionControlObserver->setModel(0);
     }
 
     if (current) {
         Q_ASSERT(qobject_cast<KFileItemModel*>(current));
         KFileItemModel* fileItemModel = static_cast<KFileItemModel*>(current);
         connect(fileItemModel, &KFileItemModel::directoryLoadingCompleted, this, &DolphinView::slotDirectoryLoadingCompleted);
         m_versionControlObserver->setModel(fileItemModel);
     }
 }
 
 void DolphinView::slotMouseButtonPressed(int itemIndex, Qt::MouseButtons buttons)
 {
     Q_UNUSED(itemIndex);
 
     hideToolTip();
 
     if (buttons & Qt::BackButton) {
         emit goBackRequested();
     } else if (buttons & Qt::ForwardButton) {
         emit goForwardRequested();
     }
 }
 
+void DolphinView::slotSelectedItemTextPressed(int index)
+{
+    if (GeneralSettings::renameInline()) {
+        m_twoClicksRenamingItemUrl = m_model->fileItem(index).url();
+        m_twoClicksRenamingTimer->start(QApplication::doubleClickInterval());
+    }
+}
+
 void DolphinView::slotItemCreated(const QUrl& url)
 {
     if (m_markFirstNewlySelectedItemAsCurrent) {
         markUrlAsCurrent(url);
         m_markFirstNewlySelectedItemAsCurrent = false;
     }
     m_selectedUrls << url;
 }
 
 void DolphinView::slotPasteJobResult(KJob *job)
 {
     if (job->error()) {
         emit errorMessage(job->errorString());
     }
     if (!m_selectedUrls.isEmpty()) {
         m_selectedUrls << KDirModel::simplifiedUrlList(m_selectedUrls);
     }
 }
 
 void DolphinView::slotSelectionChanged(const KItemSet& current, const KItemSet& previous)
 {
     const int currentCount = current.count();
     const int previousCount = previous.count();
     const bool selectionStateChanged = (currentCount == 0 && previousCount  > 0) ||
                                        (currentCount >  0 && previousCount == 0);
 
     // If nothing has been selected before and something got selected (or if something
     // was selected before and now nothing is selected) the selectionChangedSignal must
     // be emitted asynchronously as fast as possible to update the edit-actions.
     m_selectionChangedTimer->setInterval(selectionStateChanged ? 0 : 300);
     m_selectionChangedTimer->start();
 }
 
 void DolphinView::emitSelectionChangedSignal()
 {
     m_selectionChangedTimer->stop();
     emit selectionChanged(selectedItems());
 }
 
 void DolphinView::updateSortRole(const QByteArray& role)
 {
     ViewProperties props(viewPropertiesUrl());
     props.setSortRole(role);
 
     KItemModelBase* model = m_container->controller()->model();
     model->setSortRole(role);
 
     emit sortRoleChanged(role);
 }
 
 void DolphinView::updateSortOrder(Qt::SortOrder order)
 {
     ViewProperties props(viewPropertiesUrl());
     props.setSortOrder(order);
 
     m_model->setSortOrder(order);
 
     emit sortOrderChanged(order);
 }
 
 void DolphinView::updateSortFoldersFirst(bool foldersFirst)
 {
     ViewProperties props(viewPropertiesUrl());
     props.setSortFoldersFirst(foldersFirst);
 
     m_model->setSortDirectoriesFirst(foldersFirst);
 
     emit sortFoldersFirstChanged(foldersFirst);
 }
 
 QPair<bool, QString> DolphinView::pasteInfo() const
 {
     const QMimeData *mimeData = QApplication::clipboard()->mimeData();
     QPair<bool, QString> info;
     info.second = KIO::pasteActionText(mimeData, &info.first, rootItem());
     return info;
 }
 
 void DolphinView::setTabsForFilesEnabled(bool tabsForFiles)
 {
     m_tabsForFiles = tabsForFiles;
 }
 
 bool DolphinView::isTabsForFilesEnabled() const
 {
     return m_tabsForFiles;
 }
 
 bool DolphinView::itemsExpandable() const
 {
     return m_mode == DetailsView;
 }
 
 void DolphinView::restoreState(QDataStream& stream)
 {
     // Read the version number of the view state and check if the version is supported.
     quint32 version = 0;
     stream >> version;
     if (version != 1) {
         // The version of the view state isn't supported, we can't restore it.
         return;
     }
 
     // Restore the current item that had the keyboard focus
     stream >> m_currentItemUrl;
 
     // Restore the previously selected items
     stream >> m_selectedUrls;
 
     // Restore the view position
     stream >> m_restoredContentsPosition;
 
     // Restore expanded folders (only relevant for the details view - will be ignored by the view in other view modes)
     QSet<QUrl> urls;
     stream >> urls;
     m_model->restoreExpandedDirectories(urls);
 }
 
 void DolphinView::saveState(QDataStream& stream)
 {
     stream << quint32(1); // View state version
 
     // Save the current item that has the keyboard focus
     const int currentIndex = m_container->controller()->selectionManager()->currentItem();
     if (currentIndex != -1) {
         KFileItem item = m_model->fileItem(currentIndex);
         Q_ASSERT(!item.isNull()); // If the current index is valid a item must exist
         QUrl currentItemUrl = item.url();
         stream << currentItemUrl;
     } else {
         stream << QUrl();
     }
 
     // Save the selected urls
     stream << selectedItems().urlList();
 
     // Save view position
     const qreal x = m_container->horizontalScrollBar()->value();
     const qreal y = m_container->verticalScrollBar()->value();
     stream << QPoint(x, y);
 
     // Save expanded folders (only relevant for the details view - the set will be empty in other view modes)
     stream << m_model->expandedDirectories();
 }
 
 KFileItem DolphinView::rootItem() const
 {
     return m_model->rootItem();
 }
 
 void DolphinView::setViewPropertiesContext(const QString& context)
 {
     m_viewPropertiesContext = context;
 }
 
 QString DolphinView::viewPropertiesContext() const
 {
     return m_viewPropertiesContext;
 }
 
 QUrl DolphinView::openItemAsFolderUrl(const KFileItem& item, const bool browseThroughArchives)
 {
     if (item.isNull()) {
         return QUrl();
     }
 
     QUrl url = item.targetUrl();
 
     if (item.isDir()) {
         return url;
     }
 
     if (item.isMimeTypeKnown()) {
         const QString& mimetype = item.mimetype();
 
         if (browseThroughArchives && item.isFile() && url.isLocalFile()) {
             // Generic mechanism for redirecting to tar:/<path>/ when clicking on a tar file,
             // zip:/<path>/ when clicking on a zip file, etc.
             // The .protocol file specifies the mimetype that the kioslave handles.
             // Note that we don't use mimetype inheritance since we don't want to
             // open OpenDocument files as zip folders...
             const QString& protocol = KProtocolManager::protocolForArchiveMimetype(mimetype);
             if (!protocol.isEmpty()) {
                 url.setScheme(protocol);
                 return url;
             }
         }
 
         if (mimetype == QLatin1String("application/x-desktop")) {
             // Redirect to the URL in Type=Link desktop files, unless it is a http(s) URL.
             KDesktopFile desktopFile(url.toLocalFile());
             if (desktopFile.hasLinkType()) {
                 const QString linkUrl = desktopFile.readUrl();
                 if (!linkUrl.startsWith(QLatin1String("http"))) {
                     return QUrl::fromUserInput(linkUrl);
                 }
             }
         }
     }
 
     return QUrl();
 }
 
 void DolphinView::observeCreatedItem(const QUrl& url)
 {
     if (m_active) {
         forceUrlsSelection(url, {url});
     }
 }
 
 void DolphinView::slotDirectoryRedirection(const QUrl& oldUrl, const QUrl& newUrl)
 {
     if (oldUrl.matches(url(), QUrl::StripTrailingSlash)) {
         emit redirection(oldUrl, newUrl);
         m_url = newUrl; // #186947
     }
 }
 
 void DolphinView::updateViewState()
 {
     if (m_currentItemUrl != QUrl()) {
         KItemListSelectionManager* selectionManager = m_container->controller()->selectionManager();
         const int currentIndex = m_model->index(m_currentItemUrl);
         if (currentIndex != -1) {
             selectionManager->setCurrentItem(currentIndex);
 
             // scroll to current item and reset the state
             if (m_scrollToCurrentItem) {
                 m_view->scrollToItem(currentIndex);
                 m_scrollToCurrentItem = false;
             }
         } else {
             selectionManager->setCurrentItem(0);
         }
 
         m_currentItemUrl = QUrl();
     }
 
     if (!m_restoredContentsPosition.isNull()) {
         const int x = m_restoredContentsPosition.x();
         const int y = m_restoredContentsPosition.y();
         m_restoredContentsPosition = QPoint();
 
         m_container->horizontalScrollBar()->setValue(x);
         m_container->verticalScrollBar()->setValue(y);
     }
 
     if (!m_selectedUrls.isEmpty()) {
         KItemListSelectionManager* selectionManager = m_container->controller()->selectionManager();
 
         if (m_clearSelectionBeforeSelectingNewItems) {
             selectionManager->clearSelection();
             m_clearSelectionBeforeSelectingNewItems = false;
         }
 
         KItemSet selectedItems = selectionManager->selectedItems();
 
         QList<QUrl>::iterator it = m_selectedUrls.begin();
         while (it != m_selectedUrls.end()) {
             const int index = m_model->index(*it);
             if (index >= 0) {
                 selectedItems.insert(index);
                 it = m_selectedUrls.erase(it);
             } else {
                  ++it;
             }
         }
 
         selectionManager->beginAnchoredSelection(selectionManager->currentItem());
         selectionManager->setSelectedItems(selectedItems);
     }
 }
 
 void DolphinView::hideToolTip()
 {
     if (GeneralSettings::showToolTips()) {
         m_toolTipManager->hideToolTip();
     }
 }
 
 void DolphinView::calculateItemCount(int& fileCount,
                                      int& folderCount,
                                      KIO::filesize_t& totalFileSize) const
 {
     const int itemCount = m_model->count();
     for (int i = 0; i < itemCount; ++i) {
         const KFileItem item = m_model->fileItem(i);
         if (item.isDir()) {
             ++folderCount;
         } else {
             ++fileCount;
             totalFileSize += item.size();
         }
     }
 }
 
+void DolphinView::slotTwoClicksRenamingTimerTimeout()
+{
+    const KItemListSelectionManager* selectionManager = m_container->controller()->selectionManager();
+
+    // verify that only one item is selected and that no item is dragged
+    if (selectionManager->selectedItems().count() == 1 && !m_dragging) {
+        const int index = selectionManager->currentItem();
+        const QUrl fileItemUrl = m_model->fileItem(index).url();
+
+        // check if the selected item was the same item that started the twoClicksRenaming
+        if (fileItemUrl.isValid() && m_twoClicksRenamingItemUrl == fileItemUrl) {
+            renameSelectedItems();
+        }
+    }
+}
+
 void DolphinView::slotTrashFileFinished(KJob* job)
 {
     if (job->error() == 0) {
         emit operationCompletedMessage(i18nc("@info:status", "Trash operation completed."));
     } else if (job->error() != KIO::ERR_USER_CANCELED) {
         emit errorMessage(job->errorString());
     }
 }
 
 void DolphinView::slotDeleteFileFinished(KJob* job)
 {
     if (job->error() == 0) {
         emit operationCompletedMessage(i18nc("@info:status", "Delete operation completed."));
     } else if (job->error() != KIO::ERR_USER_CANCELED) {
         emit errorMessage(job->errorString());
     }
 }
 
 void DolphinView::slotRenamingResult(KJob* job)
 {
     if (job->error()) {
         KIO::CopyJob *copyJob = qobject_cast<KIO::CopyJob *>(job);
         Q_ASSERT(copyJob);
         const QUrl newUrl = copyJob->destUrl();
         const int index = m_model->index(newUrl);
         if (index >= 0) {
             QHash<QByteArray, QVariant> data;
             const QUrl oldUrl = copyJob->srcUrls().at(0);
             data.insert("text", oldUrl.fileName());
             m_model->setData(index, data);
         }
     }
 }
 
 void DolphinView::slotDirectoryLoadingStarted()
 {
     // Disable the writestate temporary until it can be determined in a fast way
     // in DolphinView::slotLoadingCompleted()
     if (m_isFolderWritable) {
         m_isFolderWritable = false;
         emit writeStateChanged(m_isFolderWritable);
     }
 
     emit directoryLoadingStarted();
 }
 
 void DolphinView::slotDirectoryLoadingCompleted()
 {
     // Update the view-state. This has to be done asynchronously
     // because the view might not be in its final state yet.
     QTimer::singleShot(0, this, &DolphinView::updateViewState);
 
     emit directoryLoadingCompleted();
 
     updateWritableState();
 }
 
 void DolphinView::slotItemsChanged()
 {
     m_assureVisibleCurrentIndex = false;
 }
 
 void DolphinView::slotSortOrderChangedByHeader(Qt::SortOrder current, Qt::SortOrder previous)
 {
     Q_UNUSED(previous);
     Q_ASSERT(m_model->sortOrder() == current);
 
     ViewProperties props(viewPropertiesUrl());
     props.setSortOrder(current);
 
     emit sortOrderChanged(current);
 }
 
 void DolphinView::slotSortRoleChangedByHeader(const QByteArray& current, const QByteArray& previous)
 {
     Q_UNUSED(previous);
     Q_ASSERT(m_model->sortRole() == current);
 
     ViewProperties props(viewPropertiesUrl());
     props.setSortRole(current);
 
     emit sortRoleChanged(current);
 }
 
 void DolphinView::slotVisibleRolesChangedByHeader(const QList<QByteArray>& current,
                                                   const QList<QByteArray>& previous)
 {
     Q_UNUSED(previous);
     Q_ASSERT(m_container->controller()->view()->visibleRoles() == current);
 
     const QList<QByteArray> previousVisibleRoles = m_visibleRoles;
 
     m_visibleRoles = current;
 
     ViewProperties props(viewPropertiesUrl());
     props.setVisibleRoles(m_visibleRoles);
 
     emit visibleRolesChanged(m_visibleRoles, previousVisibleRoles);
 }
 
 void DolphinView::slotRoleEditingCanceled()
 {
     disconnect(m_view, &DolphinItemListView::roleEditingFinished,
                this, &DolphinView::slotRoleEditingFinished);
 }
 
 void DolphinView::slotRoleEditingFinished(int index, const QByteArray& role, const QVariant& value)
 {
     disconnect(m_view, &DolphinItemListView::roleEditingFinished,
                this, &DolphinView::slotRoleEditingFinished);
 
     if (index < 0 || index >= m_model->count()) {
         return;
     }
 
     if (role == "text") {
         const KFileItem oldItem = m_model->fileItem(index);
         const QString newName = value.toString();
         if (!newName.isEmpty() && newName != oldItem.text() && newName != QLatin1String(".") && newName != QLatin1String("..")) {
             const QUrl oldUrl = oldItem.url();
 
             QUrl newUrl = oldUrl.adjusted(QUrl::RemoveFilename);
             newUrl.setPath(newUrl.path() + KIO::encodeFileName(newName));
 
             const bool newNameExistsAlready = (m_model->index(newUrl) >= 0);
             if (!newNameExistsAlready) {
                 // Only change the data in the model if no item with the new name
                 // is in the model yet. If there is an item with the new name
                 // already, calling KIO::CopyJob will open a dialog
                 // asking for a new name, and KFileItemModel will update the
                 // data when the dir lister signals that the file name has changed.
                 QHash<QByteArray, QVariant> data;
                 data.insert(role, value);
                 m_model->setData(index, data);
             }
 
             KIO::Job * job = KIO::moveAs(oldUrl, newUrl);
             KJobWidgets::setWindow(job, this);
             KIO::FileUndoManager::self()->recordJob(KIO::FileUndoManager::Rename, {oldUrl}, newUrl, job);
             job->uiDelegate()->setAutoErrorHandlingEnabled(true);
 
             forceUrlsSelection(newUrl, {newUrl});
 
             if (!newNameExistsAlready) {
                 // Only connect the result signal if there is no item with the new name
                 // in the model yet, see bug 328262.
                 connect(job, &KJob::result, this, &DolphinView::slotRenamingResult);
             }
         }
     }
 }
 
 void DolphinView::loadDirectory(const QUrl& url, bool reload)
 {
     if (!url.isValid()) {
         const QString location(url.toDisplayString(QUrl::PreferLocalFile));
         if (location.isEmpty()) {
             emit errorMessage(i18nc("@info:status", "The location is empty."));
         } else {
             emit errorMessage(i18nc("@info:status", "The location '%1' is invalid.", location));
         }
         return;
     }
 
     if (reload) {
         m_model->refreshDirectory(url);
     } else {
         m_model->loadDirectory(url);
     }
 }
 
 void DolphinView::applyViewProperties()
 {
     const ViewProperties props(viewPropertiesUrl());
     applyViewProperties(props);
 }
 
 void DolphinView::applyViewProperties(const ViewProperties& props)
 {
     m_view->beginTransaction();
 
     const Mode mode = props.viewMode();
     if (m_mode != mode) {
         const Mode previousMode = m_mode;
         m_mode = mode;
 
         // Changing the mode might result in changing
         // the zoom level. Remember the old zoom level so
         // that zoomLevelChanged() can get emitted.
         const int oldZoomLevel = m_view->zoomLevel();
         applyModeToView();
 
         emit modeChanged(m_mode, previousMode);
 
         if (m_view->zoomLevel() != oldZoomLevel) {
             emit zoomLevelChanged(m_view->zoomLevel(), oldZoomLevel);
         }
     }
 
     const bool hiddenFilesShown = props.hiddenFilesShown();
     if (hiddenFilesShown != m_model->showHiddenFiles()) {
         m_model->setShowHiddenFiles(hiddenFilesShown);
         emit hiddenFilesShownChanged(hiddenFilesShown);
     }
 
     const bool groupedSorting = props.groupedSorting();
     if (groupedSorting != m_model->groupedSorting()) {
         m_model->setGroupedSorting(groupedSorting);
         emit groupedSortingChanged(groupedSorting);
     }
 
     const QByteArray sortRole = props.sortRole();
     if (sortRole != m_model->sortRole()) {
         m_model->setSortRole(sortRole);
         emit sortRoleChanged(sortRole);
     }
 
     const Qt::SortOrder sortOrder = props.sortOrder();
     if (sortOrder != m_model->sortOrder()) {
         m_model->setSortOrder(sortOrder);
         emit sortOrderChanged(sortOrder);
     }
 
     const bool sortFoldersFirst = props.sortFoldersFirst();
     if (sortFoldersFirst != m_model->sortDirectoriesFirst()) {
         m_model->setSortDirectoriesFirst(sortFoldersFirst);
         emit sortFoldersFirstChanged(sortFoldersFirst);
     }
 
     const QList<QByteArray> visibleRoles = props.visibleRoles();
     if (visibleRoles != m_visibleRoles) {
         const QList<QByteArray> previousVisibleRoles = m_visibleRoles;
         m_visibleRoles = visibleRoles;
         m_view->setVisibleRoles(visibleRoles);
         emit visibleRolesChanged(m_visibleRoles, previousVisibleRoles);
     }
 
     const bool previewsShown = props.previewsShown();
     if (previewsShown != m_view->previewsShown()) {
         const int oldZoomLevel = zoomLevel();
 
         m_view->setPreviewsShown(previewsShown);
         emit previewsShownChanged(previewsShown);
 
         // Changing the preview-state might result in a changed zoom-level
         if (oldZoomLevel != zoomLevel()) {
             emit zoomLevelChanged(zoomLevel(), oldZoomLevel);
         }
     }
 
     KItemListView* itemListView = m_container->controller()->view();
     if (itemListView->isHeaderVisible()) {
         KItemListHeader* header = itemListView->header();
         const QList<int> headerColumnWidths = props.headerColumnWidths();
         const int rolesCount = m_visibleRoles.count();
         if (headerColumnWidths.count() == rolesCount) {
             header->setAutomaticColumnResizing(false);
 
             QHash<QByteArray, qreal> columnWidths;
             for (int i = 0; i < rolesCount; ++i) {
                 columnWidths.insert(m_visibleRoles[i], headerColumnWidths[i]);
             }
             header->setColumnWidths(columnWidths);
         } else {
             header->setAutomaticColumnResizing(true);
         }
     }
 
     m_view->endTransaction();
 }
 
 void DolphinView::applyModeToView()
 {
     switch (m_mode) {
     case IconsView:   m_view->setItemLayout(KFileItemListView::IconsLayout); break;
     case CompactView: m_view->setItemLayout(KFileItemListView::CompactLayout); break;
     case DetailsView: m_view->setItemLayout(KFileItemListView::DetailsLayout); break;
     default: Q_ASSERT(false); break;
     }
 }
 
 void DolphinView::pasteToUrl(const QUrl& url)
 {
     KIO::PasteJob *job = KIO::paste(QApplication::clipboard()->mimeData(), url);
     KJobWidgets::setWindow(job, this);
     m_clearSelectionBeforeSelectingNewItems = true;
     m_markFirstNewlySelectedItemAsCurrent = true;
     connect(job, &KIO::PasteJob::itemCreated, this, &DolphinView::slotItemCreated);
     connect(job, &KIO::PasteJob::result, this, &DolphinView::slotPasteJobResult);
 }
 
 QList<QUrl> DolphinView::simplifiedSelectedUrls() const
 {
     QList<QUrl> urls;
 
     const KFileItemList items = selectedItems();
     urls.reserve(items.count());
     foreach (const KFileItem& item, items) {
         urls.append(item.url());
     }
 
     if (itemsExpandable()) {
         // TODO: Check if we still need KDirModel for this in KDE 5.0
         urls = KDirModel::simplifiedUrlList(urls);
     }
 
     return urls;
 }
 
 QMimeData* DolphinView::selectionMimeData() const
 {
     const KItemListSelectionManager* selectionManager = m_container->controller()->selectionManager();
     const KItemSet selectedIndexes = selectionManager->selectedItems();
 
     return m_model->createMimeData(selectedIndexes);
 }
 
 void DolphinView::updateWritableState()
 {
     const bool wasFolderWritable = m_isFolderWritable;
     m_isFolderWritable = false;
 
     KFileItem item = m_model->rootItem();
     if (item.isNull()) {
         // Try to find out if the URL is writable even if the "root item" is
         // null, see https://bugs.kde.org/show_bug.cgi?id=330001
         item = KFileItem(url());
         item.setDelayedMimeTypes(true);
     }
 
     KFileItemListProperties capabilities(KFileItemList() << item);
     m_isFolderWritable = capabilities.supportsWriting();
 
     if (m_isFolderWritable != wasFolderWritable) {
         emit writeStateChanged(m_isFolderWritable);
     }
 }
 
 QUrl DolphinView::viewPropertiesUrl() const
 {
     if (m_viewPropertiesContext.isEmpty()) {
         return m_url;
     }
 
     QUrl url;
     url.setScheme(m_url.scheme());
     url.setPath(m_viewPropertiesContext);
     return url;
 }
 
 void DolphinView::slotRenameDialogRenamingFinished(const QList<QUrl>& urls)
 {
     forceUrlsSelection(urls.first(), urls);
 }
 
 void DolphinView::forceUrlsSelection(const QUrl& current, const QList<QUrl>& selected)
 {
     clearSelection();
     m_clearSelectionBeforeSelectingNewItems = true;
     markUrlAsCurrent(current);
     markUrlsAsSelected(selected);
 }
diff --git a/src/views/dolphinview.h b/src/views/dolphinview.h
index 911103b5d..2df1cf9e4 100644
--- a/src/views/dolphinview.h
+++ b/src/views/dolphinview.h
@@ -1,816 +1,824 @@
 /***************************************************************************
  *   Copyright (C) 2006-2009 by Peter Penz <peter.penz19@gmail.com>        *
  *   Copyright (C) 2006 by Gregor Kališnik <gregor@podnapisi.net>          *
  *                                                                         *
  *   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 DOLPHINVIEW_H
 #define DOLPHINVIEW_H
 
 #include <config-baloo.h>
 
 #include "dolphin_export.h"
 
 #include <kparts/part.h>
 #include <KFileItem>
 #include <kio/fileundomanager.h>
 #include <KIO/Job>
 #include <QUrl>
 #include <QMimeData>
 #include <QWidget>
 
 typedef KIO::FileUndoManager::CommandType CommandType;
 class QVBoxLayout;
 class DolphinItemListView;
 class KFileItemModel;
 class KItemListContainer;
 class KItemModelBase;
 class KItemSet;
 class ToolTipManager;
 class VersionControlObserver;
 class ViewProperties;
 class QGraphicsSceneDragDropEvent;
 class QRegExp;
 
 /**
  * @short Represents a view for the directory content.
  *
  * View modes for icons, compact and details are supported. It's
  * possible to adjust:
  * - sort order
  * - sort type
  * - show hidden files
  * - show previews
  * - enable grouping
  */
 class DOLPHIN_EXPORT DolphinView : public QWidget
 {
     Q_OBJECT
 
 public:
     /**
      * Defines the view mode for a directory. The
      * view mode is automatically updated if the directory itself
      * defines a view mode (see class ViewProperties for details).
      */
     enum Mode
     {
         /**
          * The items are shown as icons with a name-label below.
          */
         IconsView = 0,
 
         /**
          * The icon, the name and the size of the items are
          * shown per default as a table.
          */
         DetailsView,
 
         /**
          * The items are shown as icons with the name-label aligned
          * to the right side.
          */
         CompactView
     };
 
     /**
      * @param url              Specifies the content which should be shown.
      * @param parent           Parent widget of the view.
      */
     DolphinView(const QUrl& url, QWidget* parent);
 
     virtual ~DolphinView();
 
     /**
      * Returns the current active URL, where all actions are applied.
      * The URL navigator is synchronized with this URL.
      */
     QUrl url() const;
 
     /**
      * If \a active is true, the view will marked as active. The active
      * view is defined as view where all actions are applied to.
      */
     void setActive(bool active);
     bool isActive() const;
 
     /**
      * Changes the view mode for the current directory to \a mode.
      * If the view properties should be remembered for each directory
      * (GeneralSettings::globalViewProps() returns false), then the
      * changed view mode will be stored automatically.
      */
     void setMode(Mode mode);
     Mode mode() const;
 
     /**
      * Turns on the file preview for the all files of the current directory,
      * if \a show is true.
      * If the view properties should be remembered for each directory
      * (GeneralSettings::globalViewProps() returns false), then the
      * preview setting will be stored automatically.
      */
     void setPreviewsShown(bool show);
     bool previewsShown() const;
 
     /**
      * Shows all hidden files of the current directory,
      * if \a show is true.
      * If the view properties should be remembered for each directory
      * (GeneralSettings::globalViewProps() returns false), then the
      * show hidden file setting will be stored automatically.
      */
     void setHiddenFilesShown(bool show);
     bool hiddenFilesShown() const;
 
     /**
      * Turns on sorting by groups if \a enable is true.
      */
     void setGroupedSorting(bool grouped);
     bool groupedSorting() const;
 
     /**
      * Returns the items of the view.
      */
     KFileItemList items() const;
 
     /**
      * @return The number of items. itemsCount() is faster in comparison
      *         to items().count().
      */
     int itemsCount() const;
 
     /**
      * Returns the selected items. The list is empty if no item has been
      * selected.
      */
     KFileItemList selectedItems() const;
 
     /**
      * Returns the number of selected items (this is faster than
      * invoking selectedItems().count()).
      */
     int selectedItemsCount() const;
 
     /**
      * Marks the items indicated by \p urls to get selected after the
      * directory DolphinView::url() has been loaded. Note that nothing
      * gets selected if no loading of a directory has been triggered
      * by DolphinView::setUrl() or DolphinView::reload().
      */
     void markUrlsAsSelected(const QList<QUrl> &urls);
 
     /**
      * Marks the item indicated by \p url to be scrolled to and as the
      * current item after directory DolphinView::url() has been loaded.
      */
     void markUrlAsCurrent(const QUrl& url);
 
     /**
      * All items that match to the pattern \a pattern will get selected
      * if \a enabled is true and deselected if  \a enabled is false.
      */
     void selectItems(const QRegExp& pattern, bool enabled);
 
     /**
      * Sets the zoom level to \a level. It is assured that the used
      * level is adjusted to be inside the range ZoomLevelInfo::minimumLevel() and
      * ZoomLevelInfo::maximumLevel().
      */
     void setZoomLevel(int level);
     int zoomLevel() const;
 
     void setSortRole(const QByteArray& role);
     QByteArray sortRole() const;
 
     void setSortOrder(Qt::SortOrder order);
     Qt::SortOrder sortOrder() const;
 
     /** Sets a separate sorting with folders first (true) or a mixed sorting of files and folders (false). */
     void setSortFoldersFirst(bool foldersFirst);
     bool sortFoldersFirst() const;
 
     /** Sets the additional information which should be shown for the items. */
     void setVisibleRoles(const QList<QByteArray>& roles);
 
     /** Returns the additional information which should be shown for the items. */
     QList<QByteArray> visibleRoles() const;
 
     void reload();
 
     /**
      * Refreshes the view to get synchronized with the settings (e.g. icons size,
      * font, ...).
      */
     void readSettings();
 
     /**
      * Saves the current settings (e.g. icons size, font, ..).
      */
     void writeSettings();
 
     /**
      * Filters the currently shown items by \a nameFilter. All items
      * which contain the given filter string will be shown.
      */
     void setNameFilter(const QString& nameFilter);
     QString nameFilter() const;
 
     /**
      * Filters the currently shown items by \a filters. All items
      * whose content-type matches those given by the list of filters
      * will be shown.
      */
     void setMimeTypeFilters(const QStringList& filters);
     QStringList mimeTypeFilters() const;
 
     /**
      * Returns a textual representation of the state of the current
      * folder or selected items, suitable for use in the status bar.
      */
     QString statusBarText() const;
 
     /**
      * Returns the version control actions that are provided for the items \p items.
      * Usually the actions are presented in the context menu.
      */
     QList<QAction*> versionControlActions(const KFileItemList& items) const;
 
     /**
      * Returns the state of the paste action:
      * first is whether the action should be enabled
      * second is the text for the action
      */
     QPair<bool, QString> pasteInfo() const;
 
     /**
      * If \a tabsForFiles is true, the signal tabRequested() will also
      * emitted also for files. Per default tabs for files is disabled
      * and hence the signal tabRequested() will only be emitted for
      * directories.
      */
     void setTabsForFilesEnabled(bool tabsForFiles);
     bool isTabsForFilesEnabled() const;
 
     /**
      * Returns true if the current view allows folders to be expanded,
      * i.e. presents a hierarchical view to the user.
      */
     bool itemsExpandable() const;
 
     /**
      * Restores the view state (current item, contents position, details view expansion state)
      */
     void restoreState(QDataStream& stream);
 
     /**
      * Saves the view state (current item, contents position, details view expansion state)
      */
     void saveState(QDataStream& stream);
 
     /**
      * Returns the root item which represents the current URL.
      */
     KFileItem rootItem() const;
 
     /**
      * Sets a context that is used for remembering the view-properties.
      * Per default the context is empty and the path of the currently set URL
      * is used for remembering the view-properties. Setting a custom context
      * makes sense if specific types of URLs (e.g. search-URLs) should
      * share common view-properties.
      */
     void setViewPropertiesContext(const QString& context);
     QString viewPropertiesContext() const;
 
     /**
      * Checks if the given \a item can be opened as folder (e.g. archives).
      * This function will also adjust the \a url (e.g. change the protocol).
      * @return a valid and adjusted url if the item can be opened as folder,
      * otherwise return an empty url.
      */
     static QUrl openItemAsFolderUrl(const KFileItem& item, const bool browseThroughArchives = true);
 
 public slots:
     /**
      * Changes the directory to \a url. If the current directory is equal to
      * \a url, nothing will be done (use DolphinView::reload() instead).
      */
     void setUrl(const QUrl& url);
 
     /**
      * Selects all items.
      * @see DolphinView::selectedItems()
      */
     void selectAll();
 
     /**
      * Inverts the current selection: selected items get unselected,
      * unselected items get selected.
      * @see DolphinView::selectedItems()
      */
     void invertSelection();
 
     void clearSelection();
 
     /**
      * Triggers the renaming of the currently selected items, where
      * the user must input a new name for the items.
      */
     void renameSelectedItems();
 
     /**
      * Moves all selected items to the trash.
      */
     void trashSelectedItems();
 
     /**
      * Deletes all selected items.
      */
     void deleteSelectedItems();
 
     /**
      * Copies all selected items to the clipboard and marks
      * the items as cut.
      */
     void cutSelectedItems();
 
     /** Copies all selected items to the clipboard. */
     void copySelectedItems();
 
     /** Pastes the clipboard data to this view. */
     void paste();
 
     /**
      * Pastes the clipboard data into the currently selected
      * folder. If the current selection is not exactly one folder, no
      * paste operation is done.
      */
     void pasteIntoFolder();
 
     /**
      * Handles a drop of @p dropEvent onto widget @p dropWidget and destination @p destUrl
      */
     void dropUrls(const QUrl &destUrl, QDropEvent *dropEvent, QWidget *dropWidget);
 
     void stopLoading();
 
     /** Activates the view if the item list container gets focus. */
     virtual bool eventFilter(QObject* watched, QEvent* event) Q_DECL_OVERRIDE;
 
 signals:
     /**
      * Is emitted if the view has been activated by e. g. a mouse click.
      */
     void activated();
 
     /** Is emitted if the URL of the view has been changed to \a url. */
     void urlChanged(const QUrl& url);
 
     /**
      * Is emitted when clicking on an item with the left mouse button.
      */
     void itemActivated(const KFileItem& item);
 
     /**
      * Is emitted when multiple items have been activated by e. g.
      * context menu open with.
      */
     void itemsActivated(const KFileItemList& items);
 
     /**
      * Is emitted if items have been added or deleted.
      */
     void itemCountChanged();
 
     /**
      * Is emitted if a new tab should be opened for the URL \a url.
      */
     void tabRequested(const QUrl& url);
 
     /**
      * Is emitted if the view mode (IconsView, DetailsView,
      * PreviewsView) has been changed.
      */
     void modeChanged(DolphinView::Mode current, DolphinView::Mode previous);
 
     /** Is emitted if the 'show preview' property has been changed. */
     void previewsShownChanged(bool shown);
 
     /** Is emitted if the 'show hidden files' property has been changed. */
     void hiddenFilesShownChanged(bool shown);
 
     /** Is emitted if the 'grouped sorting' property has been changed. */
     void groupedSortingChanged(bool groupedSorting);
 
     /** Is emitted if the sorting by name, size or date has been changed. */
     void sortRoleChanged(const QByteArray& role);
 
     /** Is emitted if the sort order (ascending or descending) has been changed. */
     void sortOrderChanged(Qt::SortOrder order);
 
     /**
      * Is emitted if the sorting of files and folders (separate with folders
      * first or mixed) has been changed.
      */
     void sortFoldersFirstChanged(bool foldersFirst);
 
     /** Is emitted if the additional information shown for this view has been changed. */
     void visibleRolesChanged(const QList<QByteArray>& current,
                              const QList<QByteArray>& previous);
 
     /** Is emitted if the zoom level has been changed by zooming in or out. */
     void zoomLevelChanged(int current, int previous);
 
     /**
      * Is emitted if information of an item is requested to be shown e. g. in the panel.
      * If item is null, no item information request is pending.
      */
     void requestItemInfo(const KFileItem& item);
 
     /**
      * Is emitted whenever the selection has been changed.
      */
     void selectionChanged(const KFileItemList& selection);
 
     /**
      * Is emitted if a context menu is requested for the item \a item,
      * which is part of \a url. If the item is null, the context menu
      * for the URL should be shown and the custom actions \a customActions
      * will be added.
      */
     void requestContextMenu(const QPoint& pos,
                             const KFileItem& item,
                             const QUrl& url,
                             const QList<QAction*>& customActions);
 
     /**
      * Is emitted if an information message with the content \a msg
      * should be shown.
      */
     void infoMessage(const QString& msg);
 
     /**
      * Is emitted if an error message with the content \a msg
      * should be shown.
      */
     void errorMessage(const QString& msg);
 
     /**
      * Is emitted if an "operation completed" message with the content \a msg
      * should be shown.
      */
     void operationCompletedMessage(const QString& msg);
 
     /**
      * Is emitted after DolphinView::setUrl() has been invoked and
      * the current directory is loaded. If this signal is emitted,
      * it is assured that the view contains already the correct root
      * URL and property settings.
      */
     void directoryLoadingStarted();
 
     /**
      * Is emitted after the directory triggered by DolphinView::setUrl()
      * has been loaded.
      */
     void directoryLoadingCompleted();
 
     /**
      * Is emitted after the directory loading triggered by DolphinView::setUrl()
      * has been canceled.
      */
     void directoryLoadingCanceled();
 
     /**
      * Is emitted after DolphinView::setUrl() has been invoked and provides
      * the information how much percent of the current directory have been loaded.
      */
     void directoryLoadingProgress(int percent);
 
     /**
      * Is emitted if the sorting is done asynchronously and provides the
      * progress information of the sorting.
      */
     void directorySortingProgress(int percent);
 
     /**
      * Emitted when the file-item-model emits redirection.
      * Testcase: fish://localhost
      */
     void redirection(const QUrl& oldUrl, const QUrl& newUrl);
 
     /**
      * Is emitted when the URL set by DolphinView::setUrl() represents a file.
      * In this case no signal errorMessage() will be emitted.
      */
     void urlIsFileError(const QUrl& url);
 
     /**
      * Is emitted when the write state of the folder has been changed. The application
      * should disable all actions like "Create New..." that depend on the write
      * state.
      */
     void writeStateChanged(bool isFolderWritable);
 
     /**
      * Is emitted if the URL should be changed to the previous URL of the
      * history (e.g. because the "back"-mousebutton has been pressed).
      */
     void goBackRequested();
 
     /**
      * Is emitted if the URL should be changed to the next URL of the
      * history (e.g. because the "next"-mousebutton has been pressed).
      */
     void goForwardRequested();
 
     /**
      * Is emitted when the user wants to move the focus to another view.
      */
     void toggleActiveViewRequested();
 
     /**
      * Is emitted when the user clicks a tag or a link
      * in the metadata widget of a tooltip.
      */
     void urlActivated(const QUrl& url);
 
 protected:
     /** Changes the zoom level if Control is pressed during a wheel event. */
     virtual void wheelEvent(QWheelEvent* event) Q_DECL_OVERRIDE;
 
     virtual void hideEvent(QHideEvent* event) Q_DECL_OVERRIDE;
     virtual bool event(QEvent* event) Q_DECL_OVERRIDE;
 
 private slots:
     /**
      * Marks the view as active (DolphinView:isActive() will return true)
      * and emits the 'activated' signal if it is not already active.
      */
     void activate();
 
     void slotItemActivated(int index);
     void slotItemsActivated(const KItemSet& indexes);
     void slotItemMiddleClicked(int index);
     void slotItemContextMenuRequested(int index, const QPointF& pos);
     void slotViewContextMenuRequested(const QPointF& pos);
     void slotHeaderContextMenuRequested(const QPointF& pos);
     void slotHeaderColumnWidthChangeFinished(const QByteArray& role, qreal current);
     void slotItemHovered(int index);
     void slotItemUnhovered(int index);
     void slotItemDropEvent(int index, QGraphicsSceneDragDropEvent* event);
     void slotModelChanged(KItemModelBase* current, KItemModelBase* previous);
     void slotMouseButtonPressed(int itemIndex, Qt::MouseButtons buttons);
     void slotRenameDialogRenamingFinished(const QList<QUrl>& urls);
+    void slotSelectedItemTextPressed(int index);
 
     /*
      * Is called when new items get pasted or dropped.
      */
     void slotItemCreated(const QUrl &url);
     /*
      * Is called after all pasted or dropped items have been copied to destination.
      */
     void slotPasteJobResult(KJob *job);
 
     /**
      * Emits the signal \a selectionChanged() with a small delay. This is
      * because getting all file items for the selection can be an expensive
      * operation. Fast selection changes are collected in this case and
      * the signal is emitted only after no selection change has been done
      * within a small delay.
      */
     void slotSelectionChanged(const KItemSet& current, const KItemSet& previous);
 
     /**
      * Is called by emitDelayedSelectionChangedSignal() and emits the
      * signal \a selectionChanged() with all selected file items as parameter.
      */
     void emitSelectionChangedSignal();
 
     /**
      * Updates the view properties of the current URL to the
      * sorting given by \a role.
      */
     void updateSortRole(const QByteArray& role);
 
     /**
      * Updates the view properties of the current URL to the
      * sort order given by \a order.
      */
     void updateSortOrder(Qt::SortOrder order);
 
     /**
      * Updates the view properties of the current URL to the
      * sorting of files and folders (separate with folders first or mixed) given by \a foldersFirst.
      */
     void updateSortFoldersFirst(bool foldersFirst);
 
     /**
      * Indicates in the status bar that the delete operation
      * of the job \a job has been finished.
      */
     void slotDeleteFileFinished(KJob* job);
 
     /**
      * Indicates in the status bar that the trash operation
      * of the job \a job has been finished.
      */
     void slotTrashFileFinished(KJob* job);
 
     /**
      * Invoked when the rename job is done, for error handling.
      */
     void slotRenamingResult(KJob* job);
 
     /**
      * Invoked when the file item model has started the loading
      * of the directory specified by DolphinView::url().
      */
     void slotDirectoryLoadingStarted();
 
     /**
      * Invoked when the file item model indicates that the loading of a directory has
      * been completed. Assures that pasted items and renamed items get seleced.
      */
     void slotDirectoryLoadingCompleted();
 
     /**
      * Is invoked when items of KFileItemModel have been changed.
      */
     void slotItemsChanged();
 
     /**
      * Is invoked when the sort order has been changed by the user by clicking
      * on a header item. The view properties of the directory will get updated.
      */
     void slotSortOrderChangedByHeader(Qt::SortOrder current, Qt::SortOrder previous);
 
     /**
      * Is invoked when the sort role has been changed by the user by clicking
      * on a header item. The view properties of the directory will get updated.
      */
     void slotSortRoleChangedByHeader(const QByteArray& current, const QByteArray& previous);
 
     /**
      * Is invoked when the visible roles have been changed by the user by dragging
      * a header item. The view properties of the directory will get updated.
      */
     void slotVisibleRolesChangedByHeader(const QList<QByteArray>& current,
                                          const QList<QByteArray>& previous);
 
     void slotRoleEditingCanceled();
     void slotRoleEditingFinished(int index, const QByteArray& role, const QVariant& value);
 
     /**
      * Observes the item with the URL \a url. As soon as the directory
      * model indicates that the item is available, the item will
      * get selected and it is assured that the item stays visible.
      */
     void observeCreatedItem(const QUrl &url);
 
     /**
      * Called when a redirection happens.
      * Testcase: fish://localhost
      */
     void slotDirectoryRedirection(const QUrl& oldUrl, const QUrl& newUrl);
 
     /**
      * Applies the state that has been restored by restoreViewState()
      * to the view.
      */
     void updateViewState();
 
     void hideToolTip();
 
     /**
      * Calculates the number of currently shown files into
      * \a fileCount and the number of folders into \a folderCount.
      * The size of all files is written into \a totalFileSize.
      * It is recommend using this method instead of asking the
      * directory lister or the model directly, as it takes
      * filtering and hierarchical previews into account.
      */
     void calculateItemCount(int& fileCount, int& folderCount, KIO::filesize_t& totalFileSize) const;
 
+    void slotTwoClicksRenamingTimerTimeout();
+
 private:
     void loadDirectory(const QUrl& url, bool reload = false);
 
     /**
      * Applies the view properties which are defined by the current URL
      * to the DolphinView properties. The view properties are read from a
      * .directory file either in the current directory, or in the
      * share/apps/dolphin/view_properties/ subfolder of the user's .kde folder.
      */
     void applyViewProperties();
 
     /**
      * Applies the given view properties to the DolphinView.
      */
     void applyViewProperties(const ViewProperties& props);
 
     /**
      * Applies the m_mode property to the corresponding
      * itemlayout-property of the KItemListView.
      */
     void applyModeToView();
 
     /**
      * Helper method for DolphinView::paste() and DolphinView::pasteIntoFolder().
      * Pastes the clipboard data into the URL \a url.
      */
     void pasteToUrl(const QUrl& url);
 
     /**
      * Returns a list of URLs for all selected items. The list is
      * simplified, so that when the URLs are part of different tree
      * levels, only the parent is returned.
      */
     QList<QUrl> simplifiedSelectedUrls() const;
 
     /**
      * Returns the MIME data for all selected items.
      */
     QMimeData* selectionMimeData() const;
 
     /**
      * Updates m_isFolderWritable dependent on whether the folder represented by
      * the current URL is writable. If the state has changed, the signal
      * writeableStateChanged() will be emitted.
      */
     void updateWritableState();
 
     /**
      * @return The current URL if no viewproperties-context is given (see
      *         DolphinView::viewPropertiesContext(), otherwise the context
      *         is returned.
      */
     QUrl viewPropertiesUrl() const;
 
     /**
      * Clears the selection and updates current item and selection according to the parameters
      *
      * @param current URL to be set as current
      * @param selected list of selected items
      */
     void forceUrlsSelection(const QUrl& current, const QList<QUrl>& selected);
 
+    void abortTwoClicksRenaming();
+
 private:
     void updatePalette();
 
     bool m_active;
     bool m_tabsForFiles;
     bool m_assureVisibleCurrentIndex;
     bool m_isFolderWritable;
     bool m_dragging; // True if a dragging is done. Required to be able to decide whether a
                      // tooltip may be shown when hovering an item.
 
     QUrl m_url;
     QString m_viewPropertiesContext;
     Mode m_mode;
     QList<QByteArray> m_visibleRoles;
 
     QVBoxLayout* m_topLayout;
 
     KFileItemModel* m_model;
     DolphinItemListView* m_view;
     KItemListContainer* m_container;
 
     ToolTipManager* m_toolTipManager;
 
     QTimer* m_selectionChangedTimer;
 
     QUrl m_currentItemUrl; // Used for making the view to remember the current URL after F5
     bool m_scrollToCurrentItem; // Used for marking we need to scroll to current item or not
     QPoint m_restoredContentsPosition;
 
     QList<QUrl> m_selectedUrls; // Used for making the view to remember selections after F5
     bool m_clearSelectionBeforeSelectingNewItems;
     bool m_markFirstNewlySelectedItemAsCurrent;
 
     VersionControlObserver* m_versionControlObserver;
 
+    QTimer* m_twoClicksRenamingTimer;
+    QUrl m_twoClicksRenamingItemUrl;
+
     // For unit tests
     friend class TestBase;
     friend class DolphinDetailsViewTest;
     friend class DolphinPart;                   // Accesses m_model
 };
 
 /// Allow using DolphinView::Mode in QVariant
 Q_DECLARE_METATYPE(DolphinView::Mode)
 
 #endif // DOLPHINVIEW_H