--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/hbwidgets/itemviews/hbtreemodeliterator_p_p.cpp	Mon Apr 19 14:02:13 2010 +0300
@@ -0,0 +1,184 @@
+/****************************************************************************
+**
+** Copyright (C) 2008-2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (developer.feedback@nokia.com)
+**
+** This file is part of the HbWidgets module of the UI Extensions for Mobile.
+**
+** GNU Lesser General Public License Usage
+** This file may be used under the terms of the GNU Lesser General Public
+** License version 2.1 as published by the Free Software Foundation and
+** appearing in the file LICENSE.LGPL included in the packaging of this file.
+** Please review the following information to ensure the GNU Lesser General
+** Public License version 2.1 requirements 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at developer.feedback@nokia.com.
+**
+****************************************************************************/
+
+#include "hbtreemodeliterator_p_p.h"
+#include "hbabstractitemcontainer_p.h"
+#include <QAbstractItemModel>
+
+HbTreeModelIteratorPrivate::HbTreeModelIteratorPrivate()
+    : HbModelIteratorPrivate(),
+    mCachedCount(CachedIndexCount()), mCachedPosition(CachedIndexCount()),
+    mItemContainer(0), mExpansionKey(0), mUseCache(true)
+{
+}
+
+HbTreeModelIteratorPrivate::~HbTreeModelIteratorPrivate()
+{
+}
+
+/*
+    Return first index belonging to specified parent
+    If parent is colapsed QModelIndex is returned
+*/
+QModelIndex HbTreeModelIteratorPrivate::first(const QModelIndex &parent) const
+{
+    if (mModel) {
+        if (!parent.isValid()
+            || isExpanded(parent)) {
+            return mModel->index(0, 0, parent);
+        }
+    }
+    return QModelIndex();
+}
+
+/*
+    Return last index belonging to specified parent - last child in whole parent branch
+*/
+QModelIndex HbTreeModelIteratorPrivate::last(const QModelIndex &parent) const
+{
+    // last(mRootIndex) when mRootIndex is not expanded return invalid index
+    if (mModel) {
+        if (!parent.isValid()
+            || isExpanded(parent)) {
+            // parent can be invalid, mModel->index instead of index.child
+            QModelIndex index = mModel->index(mModel->rowCount(parent)-1, 0, parent);
+            if (index.isValid()) {
+                while (isExpanded(index)) {
+                    QModelIndex lastChild = mModel->index(mModel->rowCount(index)-1, 0, index);
+                    if (!lastChild.isValid()) break;
+                    index = lastChild;
+                }
+            }
+            return index;
+        }
+    }
+    return QModelIndex();
+}
+
+int HbTreeModelIteratorPrivate::childIndexCount(const QModelIndex &index) const
+{
+    int itemCount = 0;
+    int rowCount = 0;
+    if (isExpanded(index)) {
+        rowCount = mModel->rowCount(index);
+        itemCount += rowCount;
+        for (int row = 0; row < rowCount; ++row) {
+            itemCount += childIndexCount(mModel->index(row, 0, index));
+        }
+    }
+
+    return itemCount;
+}
+
+void HbTreeModelIteratorPrivate::resetCache()
+{
+    mCachedCount.count = -1;
+    mCachedCount.index = QModelIndex();
+    mCachedPosition.count = -1;
+    mCachedPosition.index = QModelIndex();
+}
+
+int HbTreeModelIteratorPrivate::searchForward(const QModelIndex &index) const
+{
+    Q_Q(const HbTreeModelIterator);
+    int result = mCachedPosition.count;
+    QModelIndex startIndex = mCachedPosition.index;
+    while (startIndex != index) {
+        startIndex = q->nextIndex(startIndex);
+        result++;
+        if (!startIndex.isValid()) { //end reached, not found
+            return -1;
+        }
+    }
+    mCachedPosition.count = result;
+    mCachedPosition.index = index;
+    return result;
+}
+
+int HbTreeModelIteratorPrivate::searchBackward(const QModelIndex &index) const
+{
+    Q_Q(const HbTreeModelIterator);
+    int result = mCachedPosition.count;
+    QModelIndex startIndex = mCachedPosition.index;
+    while (startIndex != index) {
+        startIndex = q->previousIndex(startIndex);
+        result--;
+        if (startIndex == mRootIndex
+            || !startIndex.isValid()) { //start reached, not found
+            return -1;
+        }
+    }
+    mCachedPosition.count = result;
+    mCachedPosition.index = index;
+    return result;
+}
+
+QModelIndexList HbTreeModelIteratorPrivate::createParentChainList(const QModelIndex &index) const
+{
+    QModelIndex loopIndex = index;
+    QModelIndexList indexList;
+    indexList.append(loopIndex);
+    while (loopIndex != mRootIndex
+           && loopIndex.isValid()) {
+        loopIndex = loopIndex.parent();
+        indexList.prepend(loopIndex);
+    }
+    return indexList;
+}
+
+bool HbTreeModelIteratorPrivate::isExpanded(const QModelIndex &index) const
+{
+    Q_ASSERT(mItemContainer);
+    //if (index == mRootIndex) return true; // must be expanded, otherwise mean empty view
+    QVariant flags = mItemContainer->itemState(index).value(mExpansionKey);
+    if (flags.isValid() && flags.toBool() == true) {
+        return true;
+    } else {
+        return false;
+    }
+}
+
+bool HbTreeModelIteratorPrivate::isExpandedBranch(const QModelIndex &index) const
+{
+    if (!index.isValid()) {
+        // root index is expanded!
+        return (index == mRootIndex);
+    }
+
+    QModelIndexList parents = createParentChainList(index);
+    if (!parents.isEmpty()
+        && !parents.first().isValid()) {
+        // returned list contain root, it root is invalid then
+        // isExpanded return false for it, so first invalid need to be removed
+        parents.removeFirst();
+    }
+    while (!parents.isEmpty()) {
+        if (!isExpanded(parents.first())) {
+            return false;
+        }
+        parents.removeFirst();
+    }
+    return true;
+}