Hide the "Sort by Rating" and "Sort by Tags" menu entries for KDE 4.0, as currently...

[dolphin.git] / src / kcategorizedview.cpp

diff --git a/src/kcategorizedview.cpp b/src/kcategorizedview.cpp
index e88e6a383f874b1ec572f8f4f5ad8d905420b9f3..894da2caeeea2328163782cb9ee50938b5288b50 100644 (file)
--- a/src/kcategorizedview.cpp
+++ b/src/kcategorizedview.cpp
@@ -1,6 +1,6 @@
 /**
   * This file is part of the KDE project
 /**
   * This file is part of the KDE project

-  * Copyright (C) 2007 Rafael Fernández López <ereslibre@gmail.com>
+  * Copyright (C) 2007 Rafael Fernández López <ereslibre@kde.org>

   *
   * This library is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Library General Public
   *
   * This library is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Library General Public


@@ -34,6 +34,12 @@
 #include "kcategorydrawer.h"
 #include "kcategorizedsortfilterproxymodel.h"
 
 #include "kcategorydrawer.h"
 #include "kcategorizedsortfilterproxymodel.h"
 

+// By defining DOLPHIN_DRAGANDDROP the custom drag and drop implementation of
+// KCategorizedView is bypassed to have a consistent drag and drop look for all
+// views. Hopefully transparent pixmaps for drag objects will be supported in
+// Qt 4.4, so that this workaround can be skipped.
+#define DOLPHIN_DRAGANDDROP
+

 KCategorizedView::Private::Private(KCategorizedView *listView)
     : listView(listView)
     , categoryDrawer(0)
 KCategorizedView::Private::Private(KCategorizedView *listView)
     : listView(listView)
     , categoryDrawer(0)


@@ -390,6 +396,8 @@ void KCategorizedView::Private::updateScrollbars()
     int lastItemBottom = cachedRectIndex(lastIndex).top() +
                          listView->spacing() + (listView->gridSize().isEmpty() ? 0 : listView->gridSize().height()) - listView->viewport()->height();
 
     int lastItemBottom = cachedRectIndex(lastIndex).top() +
                          listView->spacing() + (listView->gridSize().isEmpty() ? 0 : listView->gridSize().height()) - listView->viewport()->height();
 

+    listView->horizontalScrollBar()->setRange(0, 0);
+

     listView->verticalScrollBar()->setSingleStep(listView->viewport()->height() / 10);
     listView->verticalScrollBar()->setPageStep(listView->viewport()->height());
     listView->verticalScrollBar()->setRange(0, lastItemBottom);
     listView->verticalScrollBar()->setSingleStep(listView->viewport()->height() / 10);
     listView->verticalScrollBar()->setPageStep(listView->viewport()->height());
     listView->verticalScrollBar()->setRange(0, lastItemBottom);


@@ -414,6 +422,36 @@ void KCategorizedView::Private::drawDraggedItems(QPainter *painter)
     }
 }
 
     }
 }
 

+void KCategorizedView::Private::layoutChanged(bool forceItemReload)
+{
+    if ((listView->viewMode() == KCategorizedView::IconMode) && proxyModel &&
+        categoryDrawer && proxyModel->isCategorizedModel() &&
+        ((forceItemReload ||
+          (modelSortRole != proxyModel->sortRole()) ||
+          (modelSortColumn != proxyModel->sortColumn()) ||
+          (modelSortOrder != proxyModel->sortOrder()) ||
+          (modelLastRowCount != proxyModel->rowCount()) ||
+          (modelCategorized != proxyModel->isCategorizedModel()))))
+    {
+        // Force the view to update all elements
+        listView->rowsInsertedArtifficial(QModelIndex(), 0, proxyModel->rowCount() - 1);
+
+        if (!forceItemReload)
+        {
+            modelSortRole = proxyModel->sortRole();
+            modelSortColumn = proxyModel->sortColumn();
+            modelSortOrder = proxyModel->sortOrder();
+            modelLastRowCount = proxyModel->rowCount();
+            modelCategorized = proxyModel->isCategorizedModel();
+        }
+    }
+    else if ((listView->viewMode() == KCategorizedView::IconMode) && proxyModel &&
+             categoryDrawer && proxyModel->isCategorizedModel())
+    {
+        updateScrollbars();
+    }
+}
+

 void KCategorizedView::Private::drawDraggedItems()
 {
     QRect rectToUpdate;
 void KCategorizedView::Private::drawDraggedItems()
 {
     QRect rectToUpdate;


@@ -456,7 +494,7 @@ void KCategorizedView::setGridSize(const QSize &size)
 {
     QListView::setGridSize(size);
 
 {
     QListView::setGridSize(size);
 

-    slotLayoutChanged();
+    d->layoutChanged(true);

 }
 
 void KCategorizedView::setModel(QAbstractItemModel *model)
 }
 
 void KCategorizedView::setModel(QAbstractItemModel *model)


@@ -483,6 +521,10 @@ void KCategorizedView::setModel(QAbstractItemModel *model)
         QObject::disconnect(d->proxyModel,
                             SIGNAL(dataChanged(QModelIndex,QModelIndex)),
                             this, SLOT(slotLayoutChanged()));
         QObject::disconnect(d->proxyModel,
                             SIGNAL(dataChanged(QModelIndex,QModelIndex)),
                             this, SLOT(slotLayoutChanged()));

+
+        QObject::disconnect(d->proxyModel,
+                            SIGNAL(rowsRemoved(QModelIndex,int,int)),
+                            this, SLOT(rowsRemoved(QModelIndex,int,int)));

     }
 
     QListView::setModel(model);
     }
 
     QListView::setModel(model);


@@ -491,6 +533,12 @@ void KCategorizedView::setModel(QAbstractItemModel *model)
 
     if (d->proxyModel)
     {
 
     if (d->proxyModel)
     {

+        d->modelSortRole = d->proxyModel->sortRole();
+        d->modelSortColumn = d->proxyModel->sortColumn();
+        d->modelSortOrder = d->proxyModel->sortOrder();
+        d->modelLastRowCount = d->proxyModel->rowCount();
+        d->modelCategorized = d->proxyModel->isCategorizedModel();
+

         QObject::connect(d->proxyModel,
                          SIGNAL(layoutChanged()),
                          this, SLOT(slotLayoutChanged()));
         QObject::connect(d->proxyModel,
                          SIGNAL(layoutChanged()),
                          this, SLOT(slotLayoutChanged()));


@@ -498,6 +546,19 @@ void KCategorizedView::setModel(QAbstractItemModel *model)
         QObject::connect(d->proxyModel,
                          SIGNAL(dataChanged(QModelIndex,QModelIndex)),
                          this, SLOT(slotLayoutChanged()));
         QObject::connect(d->proxyModel,
                          SIGNAL(dataChanged(QModelIndex,QModelIndex)),
                          this, SLOT(slotLayoutChanged()));

+
+        QObject::connect(d->proxyModel,
+                         SIGNAL(rowsRemoved(QModelIndex,int,int)),
+                         this, SLOT(rowsRemoved(QModelIndex,int,int)));
+
+        if (d->proxyModel->rowCount())
+        {
+            d->layoutChanged(true);
+        }
+    }
+    else
+    {
+        d->modelCategorized = false;

     }
 }
 
     }
 }
 


@@ -546,6 +607,10 @@ void KCategorizedView::setCategoryDrawer(KCategoryDrawer *categoryDrawer)
         QObject::disconnect(d->proxyModel,
                             SIGNAL(dataChanged(QModelIndex,QModelIndex)),
                             this, SLOT(slotLayoutChanged()));
         QObject::disconnect(d->proxyModel,
                             SIGNAL(dataChanged(QModelIndex,QModelIndex)),
                             this, SLOT(slotLayoutChanged()));

+
+        QObject::disconnect(d->proxyModel,
+                            SIGNAL(rowsRemoved(QModelIndex,int,int)),
+                            this, SLOT(rowsRemoved(QModelIndex,int,int)));

     }
     else if (categoryDrawer && d->proxyModel)
     {
     }
     else if (categoryDrawer && d->proxyModel)
     {


@@ -556,6 +621,10 @@ void KCategorizedView::setCategoryDrawer(KCategoryDrawer *categoryDrawer)
         QObject::connect(d->proxyModel,
                          SIGNAL(dataChanged(QModelIndex,QModelIndex)),
                          this, SLOT(slotLayoutChanged()));
         QObject::connect(d->proxyModel,
                          SIGNAL(dataChanged(QModelIndex,QModelIndex)),
                          this, SLOT(slotLayoutChanged()));

+
+        QObject::connect(d->proxyModel,
+                         SIGNAL(rowsRemoved(QModelIndex,int,int)),
+                         this, SLOT(rowsRemoved(QModelIndex,int,int)));

     }
 
     d->categoryDrawer = categoryDrawer;
     }
 
     d->categoryDrawer = categoryDrawer;


@@ -564,7 +633,10 @@ void KCategorizedView::setCategoryDrawer(KCategoryDrawer *categoryDrawer)
     {
         if (d->proxyModel)
         {
     {
         if (d->proxyModel)
         {

-            rowsInserted(QModelIndex(), 0, d->proxyModel->rowCount() - 1);
+            if (d->proxyModel->rowCount())
+            {
+                d->layoutChanged(true);
+            }

         }
     }
     else
         }
     }
     else


@@ -682,6 +754,7 @@ void KCategorizedView::paintEvent(QPaintEvent *event)
 
     // Redraw categories
     QStyleOptionViewItem otherOption;
 
     // Redraw categories
     QStyleOptionViewItem otherOption;

+    bool intersectedInThePast = false;

     foreach (const QString &category, d->categories)
     {
         otherOption = option;
     foreach (const QString &category, d->categories)
     {
         otherOption = option;


@@ -690,11 +763,18 @@ void KCategorizedView::paintEvent(QPaintEvent *event)
 
         if (otherOption.rect.intersects(area))
         {
 
         if (otherOption.rect.intersects(area))
         {

+            intersectedInThePast = true;
+

             QModelIndex indexToDraw = d->proxyModel->index(d->categoriesIndexes[category][0].row(), d->proxyModel->sortColumn());
 
             d->drawNewCategory(indexToDraw,
                                d->proxyModel->sortRole(), otherOption, &painter);
         }
             QModelIndex indexToDraw = d->proxyModel->index(d->categoriesIndexes[category][0].row(), d->proxyModel->sortColumn());
 
             d->drawNewCategory(indexToDraw,
                                d->proxyModel->sortRole(), otherOption, &painter);
         }

+        else if (intersectedInThePast)
+        {
+            break; // the visible area has been finished, we don't need to keep asking, the rest won't intersect
+                   // this is doable because we know that categories are correctly ordered on the list
+        }

     }
 
     if (d->mouseButtonPressed && !d->isDragging)
     }
 
     if (d->mouseButtonPressed && !d->isDragging)


@@ -768,20 +848,22 @@ void KCategorizedView::setSelection(const QRect &rect,
     if (!flags)
         return;
 
     if (!flags)
         return;
 

-    selectionModel()->clear();
-

     if (flags & QItemSelectionModel::Clear)
     {
     if (flags & QItemSelectionModel::Clear)
     {

-        d->lastSelection = QItemSelection();
+        if (!rect.intersects(d->categoryVisualRect(d->hoveredCategory)))
+        {
+            d->lastSelection = QItemSelection();
+        }

     }
 
     }
 

-    QModelIndexList dirtyIndexes = d->intersectionSet(rect);
+    selectionModel()->clear();

 
 

-    QItemSelection selection;
+    QModelIndexList dirtyIndexes = d->intersectionSet(rect);

 
     if (!dirtyIndexes.count())
     {
 
     if (!dirtyIndexes.count())
     {

-        if (d->lastSelection.count())
+        if (!d->lastSelection.isEmpty() &&
+            (rect.intersects(d->categoryVisualRect(d->hoveredCategory)) || d->mouseButtonPressed))

         {
             selectionModel()->select(d->lastSelection, flags);
         }
         {
             selectionModel()->select(d->lastSelection, flags);
         }


@@ -789,6 +871,8 @@ void KCategorizedView::setSelection(const QRect &rect,
         return;
     }
 
         return;
     }
 

+    QItemSelection selection;
+

     if (!d->mouseButtonPressed)
     {
         selection = QItemSelection(dirtyIndexes[0], dirtyIndexes[0]);
     if (!d->mouseButtonPressed)
     {
         selection = QItemSelection(dirtyIndexes[0], dirtyIndexes[0]);


@@ -924,6 +1008,7 @@ void KCategorizedView::mouseReleaseEvent(QMouseEvent *event)
     initialPressPosition.setX(initialPressPosition.x() + horizontalOffset());
 
     QItemSelection selection;
     initialPressPosition.setX(initialPressPosition.x() + horizontalOffset());
 
     QItemSelection selection;

+    QItemSelection deselection;

 
     if (initialPressPosition == d->initialPressPosition)
     {
 
     if (initialPressPosition == d->initialPressPosition)
     {


@@ -935,10 +1020,18 @@ void KCategorizedView::mouseReleaseEvent(QMouseEvent *event)
                 {
                     QModelIndex selectIndex = index.model()->index(index.row(), 0);
 
                 {
                     QModelIndex selectIndex = index.model()->index(index.row(), 0);
 

-                    selection << QItemSelectionRange(selectIndex);
+                    if (!d->lastSelection.contains(selectIndex))
+                    {
+                        selection << QItemSelectionRange(selectIndex);
+                    }
+                    else
+                    {
+                        deselection << QItemSelectionRange(selectIndex);
+                    }

                 }
 
                 selectionModel()->select(selection, QItemSelectionModel::Select);
                 }
 
                 selectionModel()->select(selection, QItemSelectionModel::Select);

+                selectionModel()->select(deselection, QItemSelectionModel::Deselect);

 
                 break;
             }
 
                 break;
             }


@@ -963,7 +1056,14 @@ void KCategorizedView::leaveEvent(QEvent *event)
 
 void KCategorizedView::startDrag(Qt::DropActions supportedActions)
 {
 
 void KCategorizedView::startDrag(Qt::DropActions supportedActions)
 {

+    // FIXME: QAbstractItemView does far better here since it sets the
+    //        pixmap of selected icons to the dragging cursor, but it sets a non
+    //        ARGB window so it is no transparent. Use QAbstractItemView when
+    //        this is fixed on Qt.
+    // QAbstractItemView::startDrag(supportedActions);
+#if !defined(DOLPHIN_DRAGANDDROP)

     QListView::startDrag(supportedActions);
     QListView::startDrag(supportedActions);

+#endif

 
     d->isDragging = false;
     d->mouseButtonPressed = false;
 
     d->isDragging = false;
     d->mouseButtonPressed = false;


@@ -989,7 +1089,11 @@ void KCategorizedView::dragMoveEvent(QDragMoveEvent *event)
     if ((viewMode() != KCategorizedView::IconMode) || !d->proxyModel ||
         !d->categoryDrawer || !d->proxyModel->isCategorizedModel())
     {
     if ((viewMode() != KCategorizedView::IconMode) || !d->proxyModel ||
         !d->categoryDrawer || !d->proxyModel->isCategorizedModel())
     {

+#if defined(DOLPHIN_DRAGANDDROP)
+        QAbstractItemView::dragMoveEvent(event);
+#else

         QListView::dragMoveEvent(event);
         QListView::dragMoveEvent(event);

+#endif

         return;
     }
 
         return;
     }
 


@@ -1000,11 +1104,24 @@ void KCategorizedView::dragLeaveEvent(QDragLeaveEvent *event)
 {
     d->dragLeftViewport = true;
 
 {
     d->dragLeftViewport = true;
 

+#if defined(DOLPHIN_DRAGANDDROP)
+    QAbstractItemView::dragLeaveEvent(event);
+#else

     QListView::dragLeaveEvent(event);
     QListView::dragLeaveEvent(event);

+#endif
+}
+
+void KCategorizedView::dropEvent(QDropEvent *event)
+{
+#if defined(DOLPHIN_DRAGANDDROP)
+    QAbstractItemView::dropEvent(event);
+#else
+    QListView::dropEvent(event);
+#endif

 }
 
 QModelIndex KCategorizedView::moveCursor(CursorAction cursorAction,
 }
 
 QModelIndex KCategorizedView::moveCursor(CursorAction cursorAction,

-                                  Qt::KeyboardModifiers modifiers)
+                                         Qt::KeyboardModifiers modifiers)

 {
     if ((viewMode() != KCategorizedView::IconMode) ||
          !d->proxyModel ||
 {
     if ((viewMode() != KCategorizedView::IconMode) ||
          !d->proxyModel ||


@@ -1047,7 +1164,7 @@ QModelIndex KCategorizedView::moveCursor(CursorAction cursorAction,
             break;
         }
 
             break;
         }
 

-        if (category == d->elementsInfo[d->proxyModel->mapToSource(current).row()].category)
+        if (category == d->elementsInfo[current.row()].category)

         {
             theCategory = category;
 
         {
             theCategory = category;
 


@@ -1059,22 +1176,21 @@ QModelIndex KCategorizedView::moveCursor(CursorAction cursorAction,
             lastCategory = category;
         }
     }
             lastCategory = category;
         }
     }

-// ### FIXME !!!
-#if 0
+

     switch (cursorAction)
     {
         case QAbstractItemView::MoveUp: {
     switch (cursorAction)
     {
         case QAbstractItemView::MoveUp: {

-            if (d->elementsInfo[d->proxyModel->mapToSource(current).row()].relativeOffsetToCategory >= elementsPerRow)
+            if (d->elementsInfo[current.row()].relativeOffsetToCategory >= elementsPerRow)

             {
             {

-                int indexToMove = d->invertedElementDictionary[current.row()].row();
-                indexToMove -= qMin(((d->elementsInfo[d->proxyModel->mapToSource(current).row()].relativeOffsetToCategory) + d->forcedSelectionPosition), elementsPerRow - d->forcedSelectionPosition + (d->elementsInfo[d->proxyModel->mapToSource(current).row()].relativeOffsetToCategory % elementsPerRow));
+                int indexToMove = current.row();
+                indexToMove -= qMin(((d->elementsInfo[current.row()].relativeOffsetToCategory) + d->forcedSelectionPosition), elementsPerRow - d->forcedSelectionPosition + (d->elementsInfo[current.row()].relativeOffsetToCategory % elementsPerRow));

 
 

-                return d->elementDictionary[indexToMove];
+                return d->proxyModel->index(indexToMove, 0);

             }
             else
             {
                 int lastCategoryLastRow = (d->categoriesIndexes[lastCategory].count() - 1) % elementsPerRow;
             }
             else
             {
                 int lastCategoryLastRow = (d->categoriesIndexes[lastCategory].count() - 1) % elementsPerRow;

-                int indexToMove = d->invertedElementDictionary[current.row()].row() - d->elementsInfo[d->proxyModel->mapToSource(current).row()].relativeOffsetToCategory;
+                int indexToMove = current.row() - d->elementsInfo[current.row()].relativeOffsetToCategory;

 
                 if (d->forcedSelectionPosition >= lastCategoryLastRow)
                 {
 
                 if (d->forcedSelectionPosition >= lastCategoryLastRow)
                 {


@@ -1085,22 +1201,22 @@ QModelIndex KCategorizedView::moveCursor(CursorAction cursorAction,
                     indexToMove -= qMin((lastCategoryLastRow - d->forcedSelectionPosition + 1), d->forcedSelectionPosition + elementsPerRow + 1);
                 }
 
                     indexToMove -= qMin((lastCategoryLastRow - d->forcedSelectionPosition + 1), d->forcedSelectionPosition + elementsPerRow + 1);
                 }
 

-                return d->elementDictionary[indexToMove];
+                return d->proxyModel->index(indexToMove, 0);

             }
         }
 
         case QAbstractItemView::MoveDown: {
             }
         }
 
         case QAbstractItemView::MoveDown: {

-            if (d->elementsInfo[d->proxyModel->mapToSource(current).row()].relativeOffsetToCategory < (d->categoriesIndexes[theCategory].count() - 1 - ((d->categoriesIndexes[theCategory].count() - 1) % elementsPerRow)))
+            if (d->elementsInfo[current.row()].relativeOffsetToCategory < (d->categoriesIndexes[theCategory].count() - 1 - ((d->categoriesIndexes[theCategory].count() - 1) % elementsPerRow)))

             {
             {

-                int indexToMove = d->invertedElementDictionary[current.row()].row();
-                indexToMove += qMin(elementsPerRow, d->categoriesIndexes[theCategory].count() - 1 - d->elementsInfo[d->proxyModel->mapToSource(current).row()].relativeOffsetToCategory);
+                int indexToMove = current.row();
+                indexToMove += qMin(elementsPerRow, d->categoriesIndexes[theCategory].count() - 1 - d->elementsInfo[current.row()].relativeOffsetToCategory);

 
 

-                return d->elementDictionary[indexToMove];
+                return d->proxyModel->index(indexToMove, 0);

             }
             else
             {
                 int afterCategoryLastRow = qMin(elementsPerRow, d->categoriesIndexes[afterCategory].count());
             }
             else
             {
                 int afterCategoryLastRow = qMin(elementsPerRow, d->categoriesIndexes[afterCategory].count());

-                int indexToMove = d->invertedElementDictionary[current.row()].row() + (d->categoriesIndexes[theCategory].count() - d->elementsInfo[d->proxyModel->mapToSource(current).row()].relativeOffsetToCategory);
+                int indexToMove = current.row() + (d->categoriesIndexes[theCategory].count() - d->elementsInfo[current.row()].relativeOffsetToCategory);

 
                 if (d->forcedSelectionPosition >= afterCategoryLastRow)
                 {
 
                 if (d->forcedSelectionPosition >= afterCategoryLastRow)
                 {


@@ -1111,36 +1227,56 @@ QModelIndex KCategorizedView::moveCursor(CursorAction cursorAction,
                     indexToMove += qMin(d->forcedSelectionPosition, elementsPerRow);
                 }
 
                     indexToMove += qMin(d->forcedSelectionPosition, elementsPerRow);
                 }
 

-                return d->elementDictionary[indexToMove];
+                return d->proxyModel->index(indexToMove, 0);

             }
         }
 
         case QAbstractItemView::MoveLeft:
             }
         }
 
         case QAbstractItemView::MoveLeft:

-            d->forcedSelectionPosition = d->elementsInfo[d->proxyModel->mapToSource(d->elementDictionary[d->proxyModel->index(d->invertedElementDictionary[current.row()].row() - 1, 0).row()]).row()].relativeOffsetToCategory % elementsPerRow;
+            if (layoutDirection() == Qt::RightToLeft)
+            {
+                d->forcedSelectionPosition = d->elementsInfo[current.row() + 1].relativeOffsetToCategory % elementsPerRow;
+
+                if (d->forcedSelectionPosition < 0)
+                    d->forcedSelectionPosition = (d->categoriesIndexes[theCategory].count() - 1) % elementsPerRow;
+
+                return d->proxyModel->index(current.row() + 1, 0);
+            }
+
+            d->forcedSelectionPosition = d->elementsInfo[current.row() - 1].relativeOffsetToCategory % elementsPerRow;

 
             if (d->forcedSelectionPosition < 0)
                 d->forcedSelectionPosition = (d->categoriesIndexes[theCategory].count() - 1) % elementsPerRow;
 
 
             if (d->forcedSelectionPosition < 0)
                 d->forcedSelectionPosition = (d->categoriesIndexes[theCategory].count() - 1) % elementsPerRow;
 

-            return d->elementDictionary[d->proxyModel->index(d->invertedElementDictionary[current.row()].row() - 1, 0).row()];
+            return d->proxyModel->index(current.row() - 1, 0);

 
         case QAbstractItemView::MoveRight:
 
         case QAbstractItemView::MoveRight:

-            d->forcedSelectionPosition = d->elementsInfo[d->proxyModel->mapToSource(d->elementDictionary[d->proxyModel->index(d->invertedElementDictionary[current.row()].row() + 1, 0).row()]).row()].relativeOffsetToCategory % elementsPerRow;
+            if (layoutDirection() == Qt::RightToLeft)
+            {
+                d->forcedSelectionPosition = d->elementsInfo[current.row() - 1].relativeOffsetToCategory % elementsPerRow;
+
+                if (d->forcedSelectionPosition < 0)
+                    d->forcedSelectionPosition = (d->categoriesIndexes[theCategory].count() - 1) % elementsPerRow;
+
+                return d->proxyModel->index(current.row() - 1, 0);
+            }
+
+            d->forcedSelectionPosition = d->elementsInfo[current.row() + 1].relativeOffsetToCategory % elementsPerRow;

 
             if (d->forcedSelectionPosition < 0)
                 d->forcedSelectionPosition = (d->categoriesIndexes[theCategory].count() - 1) % elementsPerRow;
 
 
             if (d->forcedSelectionPosition < 0)
                 d->forcedSelectionPosition = (d->categoriesIndexes[theCategory].count() - 1) % elementsPerRow;
 

-            return d->elementDictionary[d->proxyModel->index(d->invertedElementDictionary[current.row()].row() + 1, 0).row()];
+            return d->proxyModel->index(current.row() + 1, 0);

 
         default:
             break;
     }
 
         default:
             break;
     }

-#endif
+

     return QListView::moveCursor(cursorAction, modifiers);
 }
 
 void KCategorizedView::rowsInserted(const QModelIndex &parent,
     return QListView::moveCursor(cursorAction, modifiers);
 }
 
 void KCategorizedView::rowsInserted(const QModelIndex &parent,

-                             int start,
-                             int end)
+                                    int start,
+                                    int end)

 {
     QListView::rowsInserted(parent, start, end);
 
 {
     QListView::rowsInserted(parent, start, end);
 


@@ -1168,8 +1304,8 @@ void KCategorizedView::rowsInserted(const QModelIndex &parent,
 }
 
 void KCategorizedView::rowsInsertedArtifficial(const QModelIndex &parent,
 }
 
 void KCategorizedView::rowsInsertedArtifficial(const QModelIndex &parent,

-                                        int start,
-                                        int end)
+                                               int start,
+                                               int end)

 {
     Q_UNUSED(parent);
 
 {
     Q_UNUSED(parent);
 


@@ -1192,25 +1328,24 @@ void KCategorizedView::rowsInsertedArtifficial(const QModelIndex &parent,
         return;
     }
 
         return;
     }
 

-    // Add all elements mapped to the source model
-    for (int k = 0; k < d->proxyModel->rowCount(); k++)
-    {
-        d->biggestItemSize = QSize(qMax(sizeHintForIndex(d->proxyModel->index(k, 0)).width(),
-                                        d->biggestItemSize.width()),
-                                   qMax(sizeHintForIndex(d->proxyModel->index(k, 0)).height(),
-                                        d->biggestItemSize.height()));
-
-        d->modelIndexList << d->proxyModel->index(k, d->proxyModel->sortColumn());
-    }
-
-    // Explore categories
-    QString prevCategory = d->proxyModel->data(d->modelIndexList[0], KCategorizedSortFilterProxyModel::CategoryRole).toString();
+    // Add all elements mapped to the source model and explore categories
+    QString prevCategory = d->proxyModel->data(d->proxyModel->index(0, d->proxyModel->sortColumn()), KCategorizedSortFilterProxyModel::CategoryRole).toString();

     QString lastCategory = prevCategory;
     QModelIndexList modelIndexList;
     struct Private::ElementInfo elementInfo;
     int offset = -1;
     QString lastCategory = prevCategory;
     QModelIndexList modelIndexList;
     struct Private::ElementInfo elementInfo;
     int offset = -1;

-    foreach (const QModelIndex &index, d->modelIndexList)
+    for (int k = 0; k < d->proxyModel->rowCount(); ++k)

     {
     {

+        QModelIndex index = d->proxyModel->index(k, d->proxyModel->sortColumn());
+        QModelIndex indexSize = d->proxyModel->index(k, 0);
+
+        d->biggestItemSize = QSize(qMax(sizeHintForIndex(indexSize).width(),
+                                        d->biggestItemSize.width()),
+                                   qMax(sizeHintForIndex(indexSize).height(),
+                                        d->biggestItemSize.height()));
+
+        d->modelIndexList << index;
+

         lastCategory = d->proxyModel->data(index, KCategorizedSortFilterProxyModel::CategoryRole).toString();
 
         elementInfo.category = lastCategory;
         lastCategory = d->proxyModel->data(index, KCategorizedSortFilterProxyModel::CategoryRole).toString();
 
         elementInfo.category = lastCategory;


@@ -1242,14 +1377,14 @@ void KCategorizedView::rowsInsertedArtifficial(const QModelIndex &parent,
 }
 
 void KCategorizedView::rowsRemoved(const QModelIndex &parent,
 }
 
 void KCategorizedView::rowsRemoved(const QModelIndex &parent,

-                            int start,
-                            int end)
+                                   int start,
+                                   int end)

 {
     if ((viewMode() == KCategorizedView::IconMode) && d->proxyModel &&
         d->categoryDrawer && d->proxyModel->isCategorizedModel())
     {
         // Force the view to update all elements
 {
     if ((viewMode() == KCategorizedView::IconMode) && d->proxyModel &&
         d->categoryDrawer && d->proxyModel->isCategorizedModel())
     {
         // Force the view to update all elements

-        rowsInsertedArtifficial(parent, start, end);
+        rowsInsertedArtifficial(QModelIndex(), 0, d->proxyModel->rowCount() - 1);

     }
 }
 
     }
 }
 


@@ -1269,12 +1404,7 @@ void KCategorizedView::updateGeometries()
 
 void KCategorizedView::slotLayoutChanged()
 {
 
 void KCategorizedView::slotLayoutChanged()
 {

-    if ((viewMode() == KCategorizedView::IconMode) && d->proxyModel &&
-        d->categoryDrawer && d->proxyModel->isCategorizedModel())
-    {
-        // Force the view to update all elements
-        rowsInsertedArtifficial(QModelIndex(), 0, d->proxyModel->rowCount() - 1);
-    }
+    d->layoutChanged();

 }
 
 #include "kcategorizedview.moc"
 }
 
 #include "kcategorizedview.moc"