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

**

** 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 <hbgridview_p.h>

#include <hbgridlayout_p.h>

#include <hbgriditemcontainer_p.h>

#include <hbgridviewitem.h>

#include <hbscrollbar.h>

#include "hbmodeliterator.h"

#include <QDebug>

#include <QGraphicsView>

const QString KDefaultLayoutOption = "default";

HbGridViewPrivate::HbGridViewPrivate() : 

    mIconVisible(true), 

    mTextVisible(true)

{

}

HbGridViewPrivate::~HbGridViewPrivate()

{

}

void HbGridViewPrivate::init()

{

    Q_Q(HbGridView);

    q->connect(q, SIGNAL(scrollDirectionsChanged(Qt::Orientations)),

               q, SLOT(scrollDirectionChanged(Qt::Orientations)));

    mLayoutOptionName = KDefaultLayoutOption;

}

/*

 Utility function to find a item under certain scene pixel

 */

QModelIndex HbGridViewPrivate::itemIndexUnder(const QPointF& point)

{

    Q_Q ( HbGridView );

    QModelIndex ret = QModelIndex();

    HbAbstractViewItem* hitItem = 0;

    QList<QGraphicsItem *> items = q->scene()->items(point);

    if (!items.isEmpty()) {

        int count(items.count());

        for (int current(0); current < count; ++current) {

            QGraphicsItem *item = items.at(current);

            hitItem = viewItem(item);

            if (hitItem && hitItem->modelIndex().isValid()) {

                ret = hitItem->modelIndex();

                break;

            }

        }

    }

    return ret;

}

/*!

    \reimp

*/

bool HbGridViewPrivate::visible(HbAbstractViewItem* item, bool fullyVisible) const

{

    if (item && item->isVisible()

        && item->modelIndex().isValid()) {

        return HbAbstractItemViewPrivate::visible(item, fullyVisible);

    }

    return false;

}

void HbGridViewPrivate::setIconVisible(bool iconVisible)

{

    if (iconVisible != mIconVisible) {

        mIconVisible = iconVisible;

        relayout();

    }

}

void HbGridViewPrivate::setTextVisible(bool textVisible)

{

    if (textVisible != mTextVisible) {

        mTextVisible = textVisible;

        relayout();

    }

}

void HbGridViewPrivate::relayout()

{

    QList<HbAbstractViewItem *> items = mContainer->items();

    foreach (HbAbstractViewItem *item, items) {

        HbGridViewItem *gridItem = qobject_cast<HbGridViewItem *>(item);

        if (gridItem) {

            gridItem->updateChildItems();

        }

    }

}

qreal HbGridViewPrivate::calculateScrollBarPos() const

{

    // calculate thumb size and position

    Q_Q(const HbGridView);

    qreal thumbPos = 0.0;

    int columnCount = getScrollDirectionColumnCount();

    int rowCount = getScrollDirectionRowCount();

    qreal containerPos = getScrollDirectionContainerPos();

    qreal itemSize = getScrollDirectionItemSize();

    // add coulmnCount-1 to indexCount to get remainder included in result (rounding up)

    int modelRowCount = (mModelIterator->indexCount() + columnCount - 1) / columnCount;

    modelRowCount -= rowCount;

    QModelIndex firstItem = mContainer->items().first()->modelIndex();

    qreal firstVisibleRow = (qreal)(q->modelIterator()->indexPosition(firstItem)) / columnCount;

    firstVisibleRow += -containerPos / itemSize; // applying container pos to get trully visible row 

    thumbPos = firstVisibleRow / (qreal)modelRowCount;

    thumbPos = qBound((qreal)0.0, thumbPos, (qreal)1.0);

    return thumbPos;

}

qreal HbGridViewPrivate::calculateScrollBarThumbSize() const

{

    // calculate thumb size and position

    qreal thumbSize = 0.0;

    int columnCount = getScrollDirectionColumnCount();

    int rowCount = getScrollDirectionRowCount();

    // add coulmnCount-1 to indexCount to get remainder included in result (rounding up)

    int modelRowCount = (mModelIterator->indexCount() + columnCount - 1) / columnCount;

    thumbSize = (qreal)rowCount / (qreal)modelRowCount;

    thumbSize = qBound((qreal)0.0, thumbSize, (qreal)1.0);

    return thumbSize;

}

/*!

    Overwrites the default scroll area scrollbar updating algorithm when

    recycling is used. On recycling the scrollbar position & size is calculated

    using rows and their pixel size is not used.

*/

void HbGridViewPrivate::updateScrollBar(Qt::Orientation orientation)

{

    if (!handleScrollBar(orientation)) {

        HbScrollAreaPrivate::updateScrollBar(orientation);

    } else {

        if (mContainer->layout() && !mContainer->layout()->isActivated()) {

            mContainer->layout()->activate();

        }

        qreal thumbPos = calculateScrollBarPos();

        HbScrollBar *scrollBar = getScrollDirectionScrollBar();

        scrollBar->setValue(thumbPos);

    }

}

/*!

    \reimp

*/

void HbGridViewPrivate::setScrollBarMetrics(Qt::Orientation orientation)

{

    if (!handleScrollBar(orientation)) {

        HbScrollAreaPrivate::setScrollBarMetrics(orientation);

    } else {

        if (mContainer->layout() && !mContainer->layout()->isActivated()) {

            mContainer->layout()->activate();

        }

        qreal thumbSize = calculateScrollBarThumbSize();

        HbScrollBar *scrollBar = getScrollDirectionScrollBar();

        scrollBar->setPageSize(thumbSize);

    }

}

/*!

    \reimp

*/

void HbGridViewPrivate::setContentPosition(qreal value, Qt::Orientation orientation, bool animate)

{

    Q_Q( HbGridView );

    if (mContainer->itemRecycling() && mModelIterator->model()) {

        if (mContainer->layout() && !mContainer->layout()->isActivated()) {

            mContainer->layout()->activate();

        }

        int columnCount = getScrollDirectionColumnCount();

        int rowCount = getScrollDirectionRowCount();

        int modelRowCount = (mModelIterator->indexCount() + columnCount - 1) / columnCount;

        modelRowCount -= rowCount;

        qreal thumbPos = calculateScrollBarPos();

        qreal itemSize = getScrollDirectionItemSize();

        qreal diff = (value - thumbPos) * itemSize * modelRowCount;

        if (orientation == Qt::Vertical) {

            q->scrollByAmount(QPointF(0, diff));

        } else {

            q->scrollByAmount(QPointF(diff, 0));

        }

    } else {

        HbScrollAreaPrivate::setContentPosition(value, orientation, animate);

    }

}

QModelIndex HbGridViewPrivate::indexInTheCenter(Qt::Orientations scrollDirection) const

{

    Q_Q(const HbGridView);

    QModelIndex centerViewModelIndex; // nearest to center of the screen

    if (!mContainer->items().isEmpty()) {

        qreal centerPos;

        HbGridItemContainer *container = itemContainer();

        if (scrollDirection == Qt::Vertical) {

            // calculating row:

            centerPos = -container->pos().y() + q->boundingRect().height() / 2

                        // take rather item that is just above of view center instead of bottom one

                        - container->viewLayout()->effectiveSizeHint(Qt::MinimumSize).height() / 2;

            // calculate item row

            centerPos /= container->viewLayout()->effectiveSizeHint(Qt::MinimumSize).height();

            //calculate item index

            centerPos *= itemContainer()->columnCount();

            // go to center column

            centerPos += itemContainer()->columnCount() / 2;

        } else {

            // calculating row:

            centerPos = -container->pos().x() + q->boundingRect().width() / 2

                        // take rather item that is just on the left of view center instead of right one

                        - container->viewLayout()->effectiveSizeHint(Qt::MinimumSize).width() / 2;

            // calculate buffer row

            centerPos /= container->viewLayout()->effectiveSizeHint(Qt::MinimumSize).width();

            //calculate item index

            centerPos *= itemContainer()->rowCount();

            // go to center row

            centerPos += itemContainer()->rowCount() / 2;

        }

        int centerIndex = qRound(centerPos);

        if (centerIndex >= container->items().size()) {

            centerIndex = container->items().size() / 2;

        }

        centerViewModelIndex = container->items().at(centerIndex)->modelIndex();

    }

    return centerViewModelIndex;

}