Changeset 561 for trunk/src/gui/itemviews/qtreeview.cpp

Timestamp:

Feb 11, 2010, 11:19:06 PM (15 years ago)

Author:

Dmitry A. Kuminov

Message:

trunk: Merged in qt 4.6.1 sources.

Location:

trunk

Files:

• . (modified) (1 prop)
• src/gui/itemviews/qtreeview.cpp (modified) (61 diffs)

trunk/src/gui/itemviews/qtreeview.cpp

@@ -2 +2 @@
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
@@ -21 +22 @@
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
-** In addition, as a special exception, Nokia gives you certain
-** additional rights. These rights are described in the Nokia Qt LGPL
-** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
-** package.
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
@@ -34 +34 @@
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
-** If you are unsure which license is appropriate for your use, please
-** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
@@ -67 +67 @@
     \ingroup model-view
     \ingroup advanced
-    \mainclass
+
 
     A QTreeView implements a tree representation of items from a
@@ -216 +216 @@
     if (model == d->model)
         return;
+    if (d->model && d->model != QAbstractItemModelPrivate::staticEmptyModel()) {
+        disconnect(d->model, SIGNAL(rowsRemoved(QModelIndex,int,int)),
+                this, SLOT(rowsRemoved(QModelIndex,int,int)));
+
+        disconnect(d->model, SIGNAL(modelAboutToBeReset()), this, SLOT(_q_modelAboutToBeReset()));
+    }
+
     if (d->selectionModel) { // support row editing
         disconnect(d->selectionModel, SIGNAL(currentRowChanged(QModelIndex,QModelIndex)),
@@ -239 +246 @@
             this, SLOT(rowsRemoved(QModelIndex,int,int)));
 
-    connect(d->model, SIGNAL(columnsAboutToBeRemoved(QModelIndex,int,int)),
-            this, SLOT(_q_columnsAboutToBeRemoved(QModelIndex,int,int)));
-    connect(d->model, SIGNAL(columnsRemoved(QModelIndex,int,int)),
-            this, SLOT(_q_columnsRemoved(QModelIndex,int,int)));
-
     connect(d->model, SIGNAL(modelAboutToBeReset()), SLOT(_q_modelAboutToBeReset()));
 
     if (d->sortingEnabled)
-        sortByColumn(header()->sortIndicatorSection(), header()->sortIndicatorOrder());
+        d->_q_sortIndicatorChanged(header()->sortIndicatorSection(), header()->sortIndicatorOrder());
 }
 
@@ -268 +270 @@
     Q_ASSERT(selectionModel);
     if (d->selectionModel) {
-        if (d->allColumnsShowFocus) {
-            QObject::disconnect(d->selectionModel, SIGNAL(currentChanged(QModelIndex,QModelIndex)),
-                                this, SLOT(_q_currentChanged(QModelIndex,QModelIndex)));
-        }
         // support row editing
         disconnect(d->selectionModel, SIGNAL(currentRowChanged(QModelIndex,QModelIndex)),
@@ -281 +279 @@
 
     if (d->selectionModel) {
-        if (d->allColumnsShowFocus) {
-            QObject::connect(d->selectionModel, SIGNAL(currentChanged(QModelIndex,QModelIndex)),
-                             this, SLOT(_q_currentChanged(QModelIndex,QModelIndex)));
-        }
         // support row editing
         connect(d->selectionModel, SIGNAL(currentRowChanged(QModelIndex,QModelIndex)),
@@ -681 +675 @@
     // since QAbstractItemView::dataChanged() will get the visualRect for the items anyway
 
-    QModelIndex top = topLeft.sibling(topLeft.row(), 0);
-    int topViewIndex = d->viewIndex(top);
+    int topViewIndex = d->viewIndex(topLeft);
     if (topViewIndex == 0)
-        d->defaultItemHeight = indexRowSizeHint(top);
+        d->defaultItemHeight = indexRowSizeHint(topLeft);
     bool sizeChanged = false;
     if (topViewIndex != -1) {
@@ -692 +685 @@
             sizeChanged = (oldHeight != d->itemHeight(topViewIndex));
         } else {
-            QModelIndex bottom = bottomRight.sibling(bottomRight.row(), 0);
-            int bottomViewIndex = d->viewIndex(bottom);
+            int bottomViewIndex = d->viewIndex(bottomRight);
             for (int i = topViewIndex; i <= bottomViewIndex; ++i) {
                 int oldHeight = d->itemHeight(i);
@@ -847 +839 @@
 {
     Q_D(QTreeView);
-    d->sortingEnabled = enable;
     header()->setSortIndicatorShown(enable);
     header()->setClickable(enable);
     if (enable) {
+        //sortByColumn has to be called before we connect or set the sortingEnabled flag
+        // because otherwise it will not call sort on the model.
+        sortByColumn(header()->sortIndicatorSection(), header()->sortIndicatorOrder());
         connect(header(), SIGNAL(sortIndicatorChanged(int,Qt::SortOrder)),
-                this, SLOT(_q_sortIndicatorChanged(int, Qt::SortOrder)));
-        sortByColumn(header()->sortIndicatorSection(), header()->sortIndicatorOrder());
+                this, SLOT(_q_sortIndicatorChanged(int,Qt::SortOrder)), Qt::UniqueConnection);
     } else {
         disconnect(header(), SIGNAL(sortIndicatorChanged(int,Qt::SortOrder)),
-                   this, SLOT(_q_sortIndicatorChanged(int, Qt::SortOrder)));
-    }
+                   this, SLOT(_q_sortIndicatorChanged(int,Qt::SortOrder)));
+    }
+    d->sortingEnabled = enable;
 }
 
@@ -907 +901 @@
     if (d->allColumnsShowFocus == enable)
         return;
-    if (d->selectionModel) {
-        if (enable) {
-            QObject::connect(d->selectionModel, SIGNAL(currentChanged(QModelIndex,QModelIndex)),
-                             this, SLOT(_q_currentChanged(QModelIndex,QModelIndex)));
-        } else {
-            QObject::disconnect(d->selectionModel, SIGNAL(currentChanged(QModelIndex,QModelIndex)),
-                                this, SLOT(_q_currentChanged(QModelIndex,QModelIndex)));
-        }
-    }
     d->allColumnsShowFocus = enable;
     d->viewport->update();
@@ -1118 +1103 @@
             verticalScrollBar()->setValue(item);
         } else { // PositionAtBottom or PositionAtCenter
-            int itemLocation = item;
+            const int currentItemHeight = d->itemHeight(item);
             int y = (hint == PositionAtCenter
-                     ? area.height() / 2
+                 //we center on the current item with a preference to the top item (ie. -1)
+                     ? area.height() / 2 + currentItemHeight - 1
+                 //otherwise we simply take the whole space
                      : area.height());
-            while (y > 0 && item > 0)
-                y -= d->itemHeight(item--);
-            // end up half over the top of the area
-            if (y < 0 && item < itemLocation)
-                ++item;
-            // end up half over the bottom of the area
-            if (item >= 0 && item < itemLocation)
-                ++item;
+            if (y > currentItemHeight) {
+                while (item >= 0) {
+                    y -= d->itemHeight(item);
+                    if (y < 0) { //there is no more space left
+                        item++;
+                        break;
+                    }
+                    item--;
+                }
+            }
             verticalScrollBar()->setValue(item);
         }
@@ -1141 +1130 @@
             // nothing to do
         } else if (hint == EnsureVisible && area.contains(rect)) {
-            d->setDirtyRegion(rect);
+            d->viewport->update(rect);
             // nothing to do
         } else {
@@ -1245 +1234 @@
                 QRect oldRect = visualRect(oldIndex);
                 QRect newRect = visualRect(newIndex);
-                viewport()->update(oldRect.left() - d->indent, oldRect.top(), d->indent, oldRect.height());
-                viewport()->update(newRect.left() - d->indent, newRect.top(), d->indent, newRect.height());
+                oldRect.setLeft(oldRect.left() - d->indent);
+                newRect.setLeft(newRect.left() - d->indent);
+                //we need to paint the whole items (including the decoration) so that when the user
+                //moves the mouse over those elements they are updated
+                viewport()->update(oldRect);
+                viewport()->update(newRect);
             }
         }
@@ -1273 +1266 @@
     d->executePostedLayout();
     QPainter painter(viewport());
+#ifndef QT_NO_ANIMATION
     if (d->isAnimating()) {
-        drawTree(&painter, event->region() - d->animationRect());
+        drawTree(&painter, event->region() - d->animatedOperation.rect());
         d->drawAnimatedOperation(&painter);
-    } else {
+    } else
+#endif //QT_NO_ANIMATION
+    {
         drawTree(&painter, event->region());
 #ifndef QT_NO_DRAGANDDROP
@@ -1312 +1308 @@
     Q_Q(QTreeView);
     // we want to handle mousePress in EditingState (persistent editors)
-    if ((q->state() != QAbstractItemView::NoState
-                && q->state() != QAbstractItemView::EditingState)
+    if ((state != QAbstractItemView::NoState
+                && state != QAbstractItemView::EditingState)
                 || !viewport->rect().contains(pos))
         return true;
 
     int i = itemDecorationAt(pos);
-    if ((i != -1) && q->itemsExpandable() && hasVisibleChildren(viewItems.at(i).index)) {
+    if ((i != -1) && itemsExpandable && hasVisibleChildren(viewItems.at(i).index)) {
         if (viewItems.at(i).expanded)
             collapse(i, true);
@@ -1325 +1321 @@
         if (!isAnimating()) {
             q->updateGeometries();
-            q->viewport()->update();
+            viewport->update();
         }
         return true;
@@ -1339 +1335 @@
     QAbstractItemViewPrivate::_q_modelDestroyed();
 }
+
+/*!
+  \reimp
+
+  We have a QTreeView way of knowing what elements are on the viewport
+*/
+QItemViewPaintPairs QTreeViewPrivate::draggablePaintPairs(const QModelIndexList &indexes, QRect *r) const
+{
+    Q_ASSERT(r);
+    return QAbstractItemViewPrivate::draggablePaintPairs(indexes, r);
+    Q_Q(const QTreeView);
+    QRect &rect = *r;
+    const QRect viewportRect = viewport->rect();
+    int itemOffset = 0;
+    int row = firstVisibleItem(&itemOffset);
+    QPair<int, int> startEnd = startAndEndColumns(viewportRect);
+    QVector<int> columns;
+    for (int i = startEnd.first; i <= startEnd.second; ++i) {
+        int logical = header->logicalIndex(i);
+        if (!header->isSectionHidden(logical))
+            columns += logical;
+    }
+    QSet<QModelIndex> visibleIndexes;
+    for (; itemOffset < viewportRect.bottom() && row < viewItems.count(); ++row) {
+        const QModelIndex &index = viewItems.at(row).index;
+        for (int colIndex = 0; colIndex < columns.count(); ++colIndex)
+            visibleIndexes += index.sibling(index.row(), columns.at(colIndex));
+        itemOffset += itemHeight(row);
+    }
+
+    //now that we have the visible indexes, we can try to find those which are selected
+    QItemViewPaintPairs ret;
+    for (int i = 0; i < indexes.count(); ++i) {
+        const QModelIndex &index = indexes.at(i);
+        if (visibleIndexes.contains(index)) {
+            const QRect current = q->visualRect(index);
+            ret += qMakePair(current, index);
+            rect |= current;
+        }
+    }
+    rect &= viewportRect;
+    return ret;
+}
+
 
 /*!
@@ -1394 +1434 @@
             const int itemHeight = d->itemHeight(i);
             option.rect.setRect(0, y, viewportWidth, itemHeight);
-            option.state = state | (viewItems.at(i).expanded
-                                    ? QStyle::State_Open : QStyle::State_None);
+            option.state = state | (viewItems.at(i).expanded ? QStyle::State_Open : QStyle::State_None)
+                                 | (viewItems.at(i).hasChildren ? QStyle::State_Children : QStyle::State_None)
+                                 | (viewItems.at(i).hasMoreSiblings ? QStyle::State_Sibling : QStyle::State_None);
             d->current = i;
             d->spanning = viewItems.at(i).spanning;
@@ -1547 +1588 @@
                                  : logicalIndices.at(currentLogicalSection - 1);
         if (columnCount == 1 || (nextLogicalSection == 0 && prevLogicalSection == -1)
-            || (headerSection == 0 && nextLogicalSection == -1))
+            || (headerSection == 0 && nextLogicalSection == -1) || spanning)
             opt.viewItemPosition = QStyleOptionViewItemV4::OnlyOne;
         else if (headerSection == 0 || (nextLogicalSection != 0 && prevLogicalSection == -1))
@@ -1720 +1761 @@
 
         const bool expanded = viewItem.expanded;
-        const bool children = (((expanded && viewItem.total > 0)) // already laid out and has children
-                                || d->hasVisibleChildren(index)); // not laid out yet, so we don't know
-        bool moreSiblings = false;
-        if (d->hiddenIndexes.isEmpty())
-            moreSiblings = (d->model->rowCount(parent) - 1 > index.row());
-        else
-            moreSiblings = ((d->viewItems.size() > item +1)
-                            && (d->viewItems.at(item + 1).index.parent() == parent));
+        const bool children = viewItem.hasChildren;
+        bool moreSiblings = viewItem.hasMoreSiblings;
 
         opt.state = QStyle::State_Item | extraFlags
@@ -1816 +1851 @@
             return; // user clicked outside the items
 
-        const QModelIndex &index = d->viewItems.at(i).index;
-
-        int column = d->header->logicalIndexAt(event->x());
-        QPersistentModelIndex persistent = index.sibling(index.row(), column);
+        const QPersistentModelIndex firstColumnIndex = d->viewItems.at(i).index;
+        const QPersistentModelIndex persistent = indexAt(event->pos());
 
         if (d->pressedIndex != persistent) {
@@ -1842 +1875 @@
             && d->expandsOnDoubleClick
             && d->hasVisibleChildren(persistent)) {
-            if (!((i < d->viewItems.count()) && (d->viewItems.at(i).index == persistent))) {
+            if (!((i < d->viewItems.count()) && (d->viewItems.at(i).index == firstColumnIndex))) {
                 // find the new index of the item
                 for (i = 0; i < d->viewItems.count(); ++i) {
-                    if (d->viewItems.at(i).index == persistent)
+                    if (d->viewItems.at(i).index == firstColumnIndex)
                         break;
                 }
@@ -2073 +2106 @@
             int index = useTopIndex ? INT_MAX : INT_MIN;
             const QItemSelection selection = d->selectionModel->selection();
-            foreach (const QItemSelectionRange &range, selection) {
+            for (int i = 0; i < selection.count(); ++i) {
+                const QItemSelectionRange &range = selection.at(i);
                 int candidate = d->viewIndex(useTopIndex ? range.topLeft() : range.bottomRight());
                 if (candidate >= 0)
@@ -2087 +2121 @@
         vi = qMax(0, d->viewIndex(current));
 
+    if (isRightToLeft()) {
+        if (cursorAction == MoveRight)
+            cursorAction = MoveLeft;
+        else if (cursorAction == MoveLeft)
+            cursorAction = MoveRight;
+    }
     switch (cursorAction) {
     case MoveNext:
@@ -2408 +2448 @@
     }
 
-    if (parent != d->root && !d->isIndexExpanded(parent) && d->model->rowCount(parent) > (end - start) + 1) {
+    const int parentRowCount = d->model->rowCount(parent);
+    const int delta = end - start + 1;
+    if (parent != d->root && !d->isIndexExpanded(parent) && parentRowCount > delta) {
         QAbstractItemView::rowsInserted(parent, start, end);
         return;
@@ -2423 +2465 @@
                                                     : d->viewItems.at(parentItem).total) - 1;
 
-        int firstColumn = 0;
-        while (isColumnHidden(firstColumn) && firstColumn < header()->count() - 1)
-            ++firstColumn;
-
-        const int delta = end - start + 1;
+        if (parentRowCount == end + 1 && start > 0) {
+            //need to Update hasMoreSiblings
+            int previousRow = start - 1;
+            QModelIndex previousSibilingModelIndex = d->model->index(previousRow, 0, parent);
+            bool isHidden = d->isRowHidden(previousSibilingModelIndex);
+            while (isHidden && previousRow > 0) {
+                previousRow--;
+                previousSibilingModelIndex = d->model->index(previousRow, 0, parent);
+                isHidden = d->isRowHidden(previousSibilingModelIndex);
+            }
+            if (!isHidden) {
+                const int previousSibilling = d->viewIndex(previousSibilingModelIndex);
+                if(previousSibilling != -1)
+                    d->viewItems[previousSibilling].hasMoreSiblings = true;
+            }
+        }
+
         QVector<QTreeViewItem> insertedItems(delta);
         for (int i = 0; i < delta; ++i) {
-            insertedItems[i].index = d->model->index(i + start, firstColumn, parent);
+            insertedItems[i].index = d->model->index(i + start, 0, parent);
             insertedItems[i].level = childLevel;
+            insertedItems[i].hasChildren = d->hasVisibleChildren(insertedItems[i].index);
+            insertedItems[i].hasMoreSiblings = !((i == delta - 1) && (parentRowCount == end +1));
         }
         if (d->viewItems.isEmpty())
@@ -2473 +2529 @@
         }
 
+        if (parentItem != -1)
+            d->viewItems[parentItem].hasChildren = true;
         d->updateChildCount(parentItem, delta);
+
         updateGeometries();
         viewport()->update();
@@ -2479 +2538 @@
         d->doDelayedItemsLayout();
     } else if (parentItem != -1 && (d->model->rowCount(parent) == end - start + 1)) {
-        // the parent just went from 0 children to having some update to re-paint the decoration
+        // the parent just went from 0 children to more. update to re-paint the decoration
+        d->viewItems[parentItem].hasChildren = true;
         viewport()->update();
     }
@@ -2613 +2673 @@
         d->layout(i);
         QModelIndex idx = d->viewItems.at(i).index;
-        d->expandedIndexes.insert(idx.sibling(idx.row(), 0));
+        d->expandedIndexes.insert(idx);
     }
     updateGeometries();
@@ -2715 +2775 @@
     if (d->viewItems.isEmpty())
         return -1;
+    ensurePolished();
     int w = 0;
     QStyleOptionViewItemV4 option = d->viewOptionsV4();
@@ -2772 +2833 @@
     if (isRightToLeft()) {
         start = (start == -1 ? count - 1 : start);
-        end = (end == -1 ? 0 : end);
+        end = 0;
     } else {
         start = (start == -1 ? 0 : start);
-        end = (end == -1 ? count - 1 : end);
-    }
-
-    int tmp = start;
-    start = qMin(start, end);
-    end = qMax(tmp, end);
+        end = count - 1;
+    }
+
+    if (end < start)
+        qSwap(end, start);
 
     int height = -1;
@@ -2828 +2888 @@
 
 /*!
-  \reimp
+  \internal
 */
 void QTreeView::horizontalScrollbarAction(int action)
@@ -2860 +2920 @@
     header->setDefaultAlignment(Qt::AlignLeft|Qt::AlignVCenter);
     q->setHeader(header);
-
-    // animation
-    QObject::connect(&timeline, SIGNAL(frameChanged(int)), q, SLOT(_q_animate()));
-    QObject::connect(&timeline, SIGNAL(finished()), q, SLOT(_q_endAnimatedOperation()), Qt::QueuedConnection);
+#ifndef QT_NO_ANIMATION
+    QObject::connect(&animatedOperation, SIGNAL(finished()), q, SLOT(_q_endAnimatedOperation()));
+#endif //QT_NO_ANIMATION
 }
 
@@ -2873 +2932 @@
         return;
 
+#ifndef QT_NO_ANIMATION
     if (emitSignal && animationsEnabled)
-        prepareAnimatedOperation(item, AnimatedOperation::Expand);
-
-    QAbstractItemView::State oldState = q->state();
+        prepareAnimatedOperation(item, QVariantAnimation::Forward);
+#endif //QT_NO_ANIMATION
+    QAbstractItemView::State oldState = state;
     q->setState(QAbstractItemView::ExpandingState);
     const QModelIndex index = viewItems.at(item).index;
@@ -2884 +2944 @@
     q->setState(oldState);
 
+    if (model->canFetchMore(index))
+        model->fetchMore(index);
     if (emitSignal) {
         emit q->expanded(index);
+#ifndef QT_NO_ANIMATION
         if (animationsEnabled)
             beginAnimatedOperation();
-    }
-    if (model->canFetchMore(index))
-        model->fetchMore(index);
+#endif //QT_NO_ANIMATION
+    }
 }
 
@@ -2911 +2973 @@
         return; // nothing to do
 
+#ifndef QT_NO_ANIMATION
     if (emitSignal && animationsEnabled)
-        prepareAnimatedOperation(item, AnimatedOperation::Collapse);
-
-    QAbstractItemView::State oldState = q->state();
+        prepareAnimatedOperation(item, QVariantAnimation::Backward);
+#endif //QT_NO_ANIMATION
+
+    QAbstractItemView::State oldState = state;
     q->setState(QAbstractItemView::CollapsingState);
     expandedIndexes.erase(it);
@@ -2931 +2995 @@
     if (emitSignal) {
         emit q->collapsed(modelIndex);
+#ifndef QT_NO_ANIMATION
         if (animationsEnabled)
             beginAnimatedOperation();
-    }
-}
-
-void QTreeViewPrivate::prepareAnimatedOperation(int item, AnimatedOperation::Type type)
+#endif //QT_NO_ANIMATION
+    }
+}
+
+#ifndef QT_NO_ANIMATION
+void QTreeViewPrivate::prepareAnimatedOperation(int item, QVariantAnimation::Direction direction)
 {
     animatedOperation.item = item;
-    animatedOperation.type = type;
+    animatedOperation.viewport = viewport;
+    animatedOperation.setDirection(direction);
 
     int top = coordinateForItem(item) + itemHeight(item);
     QRect rect = viewport->rect();
     rect.setTop(top);
-    if (type == AnimatedOperation::Collapse) {
+    if (direction == QVariantAnimation::Backward) {
         const int limit = rect.height() * 2;
         int h = 0;
@@ -2951 +3019 @@
             h += itemHeight(i);
         rect.setHeight(h);
-        animatedOperation.duration = h;
-    }
-    animatedOperation.top = top;
+        animatedOperation.setEndValue(top + h);
+    }
+    animatedOperation.setStartValue(top);
     animatedOperation.before = renderTreeToPixmapForAnimation(rect);
 }
@@ -2962 +3030 @@
 
     QRect rect = viewport->rect();
-    rect.setTop(animatedOperation.top);
-    if (animatedOperation.type == AnimatedOperation::Expand) {
+    rect.setTop(animatedOperation.top());
+    if (animatedOperation.direction() == QVariantAnimation::Forward) {
         const int limit = rect.height() * 2;
         int h = 0;
@@ -2970 +3038 @@
             h += itemHeight(i);
         rect.setHeight(h);
-        animatedOperation.duration = h;
-    }
-
-    animatedOperation.after = renderTreeToPixmapForAnimation(rect);
-
-    q->setState(QAbstractItemView::AnimatingState);
-
-    timeline.stop();
-    timeline.setDuration(250);
-    timeline.setFrameRange(animatedOperation.top, animatedOperation.top + animatedOperation.duration);
-    timeline.start();
-}
-
-void QTreeViewPrivate::_q_endAnimatedOperation()
-{
-    Q_Q(QTreeView);
-    animatedOperation.before = QPixmap();
-    animatedOperation.after = QPixmap();
-    q->setState(QAbstractItemView::NoState);
-    q->updateGeometries();
-    viewport->update();
-}
-
-void QTreeViewPrivate::_q_animate()
-{
-    QRect rect = viewport->rect();
-    rect.moveTop(animatedOperation.top);
-    viewport->repaint(rect);
+        animatedOperation.setEndValue(animatedOperation.top() + h);
+    }
+
+    if (!rect.isEmpty()) {
+        animatedOperation.after = renderTreeToPixmapForAnimation(rect);
+
+        q->setState(QAbstractItemView::AnimatingState);
+        animatedOperation.start(); //let's start the animation
+    }
 }
 
 void QTreeViewPrivate::drawAnimatedOperation(QPainter *painter) const
 {
-    int start = timeline.startFrame();
-    int end = timeline.endFrame();
-    bool collapsing = animatedOperation.type == AnimatedOperation::Collapse;
-    int current = collapsing ? end - timeline.currentFrame() + start : timeline.currentFrame();
+    const int start = animatedOperation.startValue().toInt(),
+        end = animatedOperation.endValue().toInt(),
+        current = animatedOperation.currentValue().toInt();
+    bool collapsing = animatedOperation.direction() == QVariantAnimation::Backward;
     const QPixmap top = collapsing ? animatedOperation.before : animatedOperation.after;
     painter->drawPixmap(0, start, top, 0, end - current - 1, top.width(), top.height());
@@ -3048 +3097 @@
 }
 
-void QTreeViewPrivate::_q_currentChanged(const QModelIndex &current, const QModelIndex &previous)
+void QTreeViewPrivate::_q_endAnimatedOperation()
 {
     Q_Q(QTreeView);
-    if (previous.isValid()) {
-        QRect previousRect = q->visualRect(previous);
-        if (allColumnsShowFocus) {
-            previousRect.setX(0);
-            previousRect.setWidth(viewport->width());
-        }
-        viewport->update(previousRect);
-    }
-    if (current.isValid()) {
-        QRect currentRect = q->visualRect(current);
-        if (allColumnsShowFocus) {
-            currentRect.setX(0);
-            currentRect.setWidth(viewport->width());
-        }
-        viewport->update(currentRect);
-    }
-}
+    q->setState(QAbstractItemView::NoState);
+    q->updateGeometries();
+    viewport->update();
+}
+#endif //QT_NO_ANIMATION
 
 void QTreeViewPrivate::_q_modelAboutToBeReset()
@@ -3076 +3113 @@
 void QTreeViewPrivate::_q_columnsAboutToBeRemoved(const QModelIndex &parent, int start, int end)
 {
-    Q_UNUSED(parent);
     if (start <= 0 && 0 <= end)
         viewItems.clear();
+    QAbstractItemViewPrivate::_q_columnsAboutToBeRemoved(parent, start, end);
 }
 
 void QTreeViewPrivate::_q_columnsRemoved(const QModelIndex &parent, int start, int end)
 {
-    Q_UNUSED(parent);
     if (start <= 0 && 0 <= end)
         doDelayedItemsLayout();
+    QAbstractItemViewPrivate::_q_columnsRemoved(parent, start, end);
 }
 
@@ -3093 +3130 @@
     QModelIndex current;
     QModelIndex parent = (i < 0) ? (QModelIndex)root : modelIndex(i);
-    // modelIndex() will return an index that don't have a parent if column 0 is hidden,
-    // so we must make sure that parent points to the actual parent that has children.
-    if (parent != root)
-        parent = model->index(parent.row(), 0, parent.parent());
 
     if (i>=0 && !parent.isValid()) {
@@ -3130 +3163 @@
     int last = 0;
     int children = 0;
-
-    int firstColumn = 0;
-    while (header->isSectionHidden(firstColumn) && firstColumn < header->count())
-        ++firstColumn;
-
+    QTreeViewItem *item = 0;
     for (int j = first; j < first + count; ++j) {
-        current = model->index(j - first, firstColumn, parent);
-        if (isRowHidden(current.sibling(current.row(), 0))) {
+        current = model->index(j - first, 0, parent);
+        if (isRowHidden(current)) {
             ++hidden;
             last = j - hidden + children;
         } else {
             last = j - hidden + children;
-            viewItems[last].index = current;
-            viewItems[last].level = level;
-            viewItems[last].height = 0;
-            viewItems[last].spanning = q->isFirstColumnSpanned(current.row(), parent);
-            viewItems[last].expanded = false;
-            viewItems[last].total = 0;
+            if (item)
+                item->hasMoreSiblings = true;
+            item = &viewItems[last];
+            item->index = current;
+            item->level = level;
+            item->height = 0;
+            item->spanning = q->isFirstColumnSpanned(current.row(), parent);
+            item->expanded = false;
+            item->total = 0;
+            item->hasMoreSiblings = false;
             if (isIndexExpanded(current)) {
-                viewItems[last].expanded = true;
+                item->expanded = true;
                 layout(last);
-                children += viewItems[last].total;
+                item = &viewItems[last];
+                children += item->total;
+                item->hasChildren = item->total > 0;
                 last = j - hidden + children;
+            } else {
+                item->hasChildren = hasVisibleChildren(current);
             }
         }
@@ -3218 +3255 @@
 int QTreeViewPrivate::coordinateForItem(int item) const
 {
-    Q_Q(const QTreeView);
     if (verticalScrollMode == QAbstractItemView::ScrollPerPixel) {
         if (uniformRowHeights)
-            return (item * defaultItemHeight) - q->verticalScrollBar()->value();
+            return (item * defaultItemHeight) - vbar->value();
         // ### optimize (spans or caching)
         int y = 0;
         for (int i = 0; i < viewItems.count(); ++i) {
             if (i == item)
-                return y - q->verticalScrollBar()->value();
+                return y - vbar->value();
             y += itemHeight(i);
         }
     } else { // ScrollPerItem
-        int topViewItemIndex = q->verticalScrollBar()->value();
+        int topViewItemIndex = vbar->value();
         if (uniformRowHeights)
             return defaultItemHeight * (item - topViewItemIndex);
@@ -3270 +3306 @@
 int QTreeViewPrivate::itemAtCoordinate(int coordinate) const
 {
-    Q_Q(const QTreeView);
     const int itemCount = viewItems.count();
     if (itemCount == 0)
@@ -3278 +3313 @@
     if (verticalScrollMode == QAbstractItemView::ScrollPerPixel) {
         if (uniformRowHeights) {
-            const int viewItemIndex = (coordinate + q->verticalScrollBar()->value()) / defaultItemHeight;
+            const int viewItemIndex = (coordinate + vbar->value()) / defaultItemHeight;
             return ((viewItemIndex >= itemCount || viewItemIndex < 0) ? -1 : viewItemIndex);
         }
         // ### optimize
         int viewItemCoordinate = 0;
-        const int contentsCoordinate = coordinate + q->verticalScrollBar()->value();
+        const int contentsCoordinate = coordinate + vbar->value();
         for (int viewItemIndex = 0; viewItemIndex < viewItems.count(); ++viewItemIndex) {
             viewItemCoordinate += itemHeight(viewItemIndex);
@@ -3290 +3325 @@
         }
     } else { // ScrollPerItem
-        int topViewItemIndex = q->verticalScrollBar()->value();
+        int topViewItemIndex = vbar->value();
         if (uniformRowHeights) {
             if (coordinate < 0)
@@ -3320 +3355 @@
 int QTreeViewPrivate::viewIndex(const QModelIndex &_index) const
 {
-    Q_Q(const QTreeView);
     if (!_index.isValid() || viewItems.isEmpty())
         return -1;
 
     const int totalCount = viewItems.count();
-    int firstColumn = 0;
-    while (q->isColumnHidden(firstColumn) && firstColumn < header->count())
-        ++firstColumn;
-    const QModelIndex index = _index.sibling(_index.row(), firstColumn);
+    const QModelIndex index = _index.sibling(_index.row(), 0);
 
 
@@ -3386 +3417 @@
 int QTreeViewPrivate::firstVisibleItem(int *offset) const
 {
-    Q_Q(const QTreeView);
-    const int value = q->verticalScrollBar()->value();
+    const int value = vbar->value();
     if (verticalScrollMode == QAbstractItemView::ScrollPerItem) {
         if (offset)
@@ -3464 +3494 @@
         if (!viewItems.isEmpty())
             itemsInViewport = qMax(1, itemsInViewport);
-        q->verticalScrollBar()->setRange(0, viewItems.count() - itemsInViewport);
-        q->verticalScrollBar()->setPageStep(itemsInViewport);
-        q->verticalScrollBar()->setSingleStep(1);
+        vbar->setRange(0, viewItems.count() - itemsInViewport);
+        vbar->setPageStep(itemsInViewport);
+        vbar->setSingleStep(1);
     } else { // scroll per pixel
         int contentsHeight = 0;
@@ -3475 +3505 @@
                 contentsHeight += itemHeight(i);
         }
-        q->verticalScrollBar()->setRange(0, contentsHeight - viewportSize.height());
-        q->verticalScrollBar()->setPageStep(viewportSize.height());
-        q->verticalScrollBar()->setSingleStep(qMax(viewportSize.height() / (itemsInViewport + 1), 2));
+        vbar->setRange(0, contentsHeight - viewportSize.height());
+        vbar->setPageStep(viewportSize.height());
+        vbar->setSingleStep(qMax(viewportSize.height() / (itemsInViewport + 1), 2));
     }
 
@@ -3493 +3523 @@
         columnsInViewport = qMax(1, columnsInViewport);
     if (horizontalScrollMode == QAbstractItemView::ScrollPerItem) {
-        q->horizontalScrollBar()->setRange(0, columnCount - columnsInViewport);
-        q->horizontalScrollBar()->setPageStep(columnsInViewport);
-        q->horizontalScrollBar()->setSingleStep(1);
+        hbar->setRange(0, columnCount - columnsInViewport);
+        hbar->setPageStep(columnsInViewport);
+        hbar->setSingleStep(1);
     } else { // scroll per pixel
         const int horizontalLength = header->length();
         const QSize maxSize = q->maximumViewportSize();
-        if (maxSize.width() >= horizontalLength && q->verticalScrollBar()->maximum() <= 0)
+        if (maxSize.width() >= horizontalLength && vbar->maximum() <= 0)
             viewportSize = maxSize;
-        q->horizontalScrollBar()->setPageStep(viewportSize.width());
-        q->horizontalScrollBar()->setRange(0, qMax(horizontalLength - viewportSize.width(), 0));
-        q->horizontalScrollBar()->setSingleStep(qMax(viewportSize.width() / (columnsInViewport + 1), 2));
+        hbar->setPageStep(viewportSize.width());
+        hbar->setRange(0, qMax(horizontalLength - viewportSize.width(), 0));
+        hbar->setSingleStep(qMax(viewportSize.width() / (columnsInViewport + 1), 2));
     }
 }
@@ -3509 +3539 @@
 int QTreeViewPrivate::itemDecorationAt(const QPoint &pos) const
 {
-    const_cast<QTreeView *>(q_func())->executeDelayedItemsLayout();
+    executePostedLayout();
     int x = pos.x();
     int column = header->logicalIndexAt(x);
@@ -3575 +3605 @@
     current.first = -2; // -1 is not enough because -1+1 = 0
     current.second = -2;
-    foreach (int logicalColumn, logicalIndexes) {
+    for(int i = 0; i < logicalIndexes.count(); ++i) {
+        const int logicalColumn = logicalIndexes.at(i);
         if (current.second + 1 != logicalColumn) {
             if (current.first != -2) {
@@ -3714 +3745 @@
         const int delta = end - start + 1;
 
+        int previousSibiling = -1;
         int removedCount = 0;
         for (int item = firstChildItem; item <= lastChildItem; ) {
@@ -3721 +3753 @@
             const int count = viewItems.at(item).total + 1;
             if (modelIndex.row() < start) {
+                previousSibiling = item;
                 // not affected by the removal
                 item += count;
@@ -3738 +3771 @@
         }
 
+        if (previousSibiling != -1 && after && model->rowCount(parent) == start)
+            viewItems[previousSibiling].hasMoreSiblings = false;
+
+
         updateChildCount(parentItem, -removedCount);
+        if (parentItem != -1 && viewItems.at(parentItem).total == 0)
+            viewItems[parentItem].hasChildren = false; //every children have been removed;
         if (after) {
             q->updateGeometries();
@@ -3810 +3849 @@
 #endif
     QAbstractItemView::currentChanged(current, previous);
+
+    if (allColumnsShowFocus()) {
+        if (previous.isValid()) {
+            QRect previousRect = visualRect(previous);
+            previousRect.setX(0);
+            previousRect.setWidth(viewport()->width());
+            viewport()->update(previousRect);
+        }
+        if (current.isValid()) {
+            QRect currentRect = visualRect(current);
+            currentRect.setX(0);
+            currentRect.setWidth(viewport()->width());
+            viewport()->update(currentRect);
+        }
+    }
 }