/****************************************************************************

**

** 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 "hbtreeitemcontainer_p.h"

#include "hbtreeitemcontainer_p_p.h"

#include "hbtreelayout_p.h"

#include "hbabstractitemcontainer_p.h"

#include "hbabstractitemview.h"

#include "hbtreeviewitem.h"

#include "hbapplication.h"

#include "hbmodeliterator.h"

#include <qmath.h>

const int Hb_Recycle_Buffer_Shrink_Threshold = 2;

HbTreeItemContainerPrivate::HbTreeItemContainerPrivate() :

    HbAbstractItemContainerPrivate(),

    mLayout(0),

    mUserIndentation(-1.0),

    mStyleIndentation(15.0)

{

}

HbTreeItemContainerPrivate::~HbTreeItemContainerPrivate()

{

}

void HbTreeItemContainerPrivate::init()

{   

    Q_Q(HbTreeItemContainer);

    mLayout = new HbTreeLayout();

    mLayout->setContentsMargins(0, 0, 0, 0);

    q->setLayout(mLayout);

}

int HbTreeItemContainerPrivate::levelForItem(HbAbstractViewItem *item) const

{

    int level = 0;

    if (mItemView) {

        QModelIndex parentIndex = item->modelIndex().parent();

        QModelIndex rootIndex = mItemView->rootIndex();

        while (parentIndex != rootIndex && parentIndex.isValid()) {

            level++;

            parentIndex = parentIndex.parent();

        }

    }

    return level;

}

/*!

    \private

    Changes first abstract view item from item buffer to be the last one.

*/

HbAbstractViewItem *HbTreeItemContainerPrivate::shiftDownItem(QPointF& delta)

{

    Q_Q(HbTreeItemContainer);

    HbAbstractViewItem *item = 0;

    HbAbstractViewItem *lastItem = mItems.last();

    QModelIndex nextIndex = mItemView->modelIterator()->nextIndex(lastItem->modelIndex());

    if (nextIndex.isValid()) {

        item = mItems.takeFirst();

        mItems.append(item);

    }

    return item;

}

/*!

    \private

    Changes last view item from item buffer to be the first one.

*/

HbAbstractViewItem *HbTreeItemContainerPrivate::shiftUpItem(QPointF& delta)

{

    Q_Q(HbTreeItemContainer);

    HbAbstractViewItem *item = 0;

    HbAbstractViewItem *firstItem = mItems.first();

    QModelIndex previousIndex = mItemView->modelIterator()->previousIndex(firstItem->modelIndex());

    if (previousIndex.isValid()) {

        item = mItems.takeLast();

        q->itemRemoved(item);

        mItems.insert(0, item);

        q->setItemModelIndex(item, previousIndex);

        qreal itemHeight=0;

        if (q->uniformItemSizes()) {

            itemHeight = mItems.last()->preferredHeight();

        } else {

            //This is time consuming and causes backwards srolling to be slower than forwards.

            //The sizehint of the item is dirty.

            itemHeight = item->preferredHeight();

        }

        delta.setY(delta.y() + itemHeight);

    return item;

}

void HbTreeItemContainerPrivate::resolveIndentation()

{

    Q_Q(const HbTreeItemContainer);

    qreal indentation = mUserIndentation;

    if (indentation < 0.0) {

        q->style()->parameter("hb-param-margin-gene-left", indentation);

        if (indentation >= 0.0) {

            mStyleIndentation = indentation;

        } else {

            indentation = mStyleIndentation;

        }

    }

    mLayout->setIndentation(indentation);

}

qreal HbTreeItemContainerPrivate::getSmallestItemHeight() const

{

    Q_Q(const HbTreeItemContainer);

    if (mItems.count() > 0) {

        minHeight = mLayout->smallestItemHeight();

    }

        QModelIndex index;

        while (mItems.isEmpty()) {

            // in practise following conditions must apply: itemview is empty and scrollTo() has been called.

            // Starts populating items from given mFirstItemIndex

            if ( mFirstItemIndex.isValid()) {

                index = mFirstItemIndex;

                const_cast<QPersistentModelIndex&>(mFirstItemIndex) = QModelIndex();

            } else {

                index = mItemView->modelIterator()->nextIndex(index);

            }

            if (!index.isValid()) {

                break;

            }

            const_cast<HbTreeItemContainer *>(q)->insertItem(0, index);

        }

        if (!mItems.isEmpty()) {

            minHeight = mItems.first()->preferredHeight();

        }

    }

    return minHeight;

}

HbTreeItemContainer::HbTreeItemContainer(QGraphicsItem *parent) :

    HbAbstractItemContainer(*new HbTreeItemContainerPrivate, parent)

{

    Q_D(HbTreeItemContainer);

    d->q_ptr = this;

    d->init();

}

HbTreeItemContainer::HbTreeItemContainer( HbTreeItemContainerPrivate &dd, QGraphicsItem *parent) :

    HbAbstractItemContainer(dd, parent)

{

    Q_D(HbTreeItemContainer);

    d->q_ptr = this;

    d->init();

}

/*!

    Destructor.

 */

HbTreeItemContainer::~HbTreeItemContainer()

{

}

/*!

    \reimp

*/

void HbTreeItemContainer::itemRemoved(HbAbstractViewItem *item, bool animate)

{

    Q_D(HbTreeItemContainer);

}

/*!

    \reimp

*/

void HbTreeItemContainer::itemAdded(int index, HbAbstractViewItem *item, bool animate)

{

    Q_D(HbTreeItemContainer);

}

/*!

    \reimp

*/

void HbTreeItemContainer::viewResized(const QSizeF &size)

{

    Q_D(HbTreeItemContainer);

    d->mLayout->setMinimumWidth(size.width());

}

void HbTreeItemContainer::setItemModelIndex(HbAbstractViewItem *item, const QModelIndex &index)

{

    if (item && item->modelIndex() != index) {

        HbAbstractItemContainer::setItemModelIndex(item, index);

        Q_D(HbTreeItemContainer);

        d->mLayout->setItemLevel(item, d->levelForItem(item));

    }

}

qreal HbTreeItemContainer::indentation() const

{

    Q_D(const HbTreeItemContainer);

    return d->mUserIndentation;

}

void HbTreeItemContainer::setIndentation(qreal indentation)

{

    Q_D(HbTreeItemContainer);

    if (d->mUserIndentation != indentation) {

        d->mUserIndentation = indentation;

        d->resolveIndentation();

    }

}

/*!

    Calculates the optimal view item buffer size. When recycling is turned off

    returned buffer same is same as the amount of rows within the model. When 

    recycling is enabled the amount is calculated by dividing the view area with

    average item height. Average item height is taken from the average of existing

    view item's heights or by creating item using prototype for the first row.

*/

int HbTreeItemContainer::maxItemCount() const

{

    Q_D(const HbTreeItemContainer);

    int targetCount = HbAbstractItemContainer::maxItemCount();

    if (targetCount > 0

        && d->mItemRecycling

        && d->mPrototypes.count() <= 1) {

        qreal minHeight = d->getSmallestItemHeight();

        if (minHeight > 0) {

            int countEstimate = qCeil(d->mItemView->boundingRect().height() / minHeight)

                + d->mBufferSize;

            int currentCount = d->mItems.count();

            if (countEstimate < currentCount) {

                // Shrink the recycle buffer only if change is more than

                // buffer shrink threshold. 

                if (countEstimate > (currentCount - Hb_Recycle_Buffer_Shrink_Threshold)) {

                    countEstimate = currentCount;

                }

            }

            // This limits the targetCount not to be larger

            // than row count inside model.

            targetCount = qMin(targetCount, countEstimate);

        } else {

            targetCount = 0;

        }

    } 

    return targetCount;

}

bool  HbTreeItemContainer::event(QEvent *e)

{