/*
* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:    
*
*/
#include "HgMediaWallRenderer.h"
#include "hgmediawalldataprovider.h"
#include "hgquadrenderer.h"
#include "hgquad.h"
#include "hgimage.h"
#include "HgImageFader.h"
#include "hgvgquadrenderer.h"
#include <qvector3d>
#include <qtimer>
#include <qpropertyanimation>
#include <qstate.h>
#include <qabstracttransition>
#include <qstatemachine>
#include <qsignaltransition>
#include <qsequentialanimationgroup>
#include <qparallelanimationgroup>
#include <qvariantanimation>
#include <qpolygon>
#include <qpainter>
#include <qpaintengine>

const qreal KPi = 3.1415926535897932384626433832795;

static qreal lerp(qreal start, qreal end, qreal t)
{
    return start * (1.0f - t) + end * t;
}

class MyVectorAnimation : public QVariantAnimation
{
public:
    virtual void updateCurrentValue(const QVariant& value)
    {
        mValue = value.value<QVector3D>();
    }
    QVector3D getValue() const
    {
        return mValue;
    }
private:
    QVector3D mValue;
};

class HgAnimatedQuad
{
public:
    
    HgAnimatedQuad(HgQuad* start, HgQuad* end, 
        int duration) : mQuad(start)
    {        
        mPositionAnimation.setDuration(duration);
        mPositionAnimation.setKeyValueAt(0, start->position());
        mPositionAnimation.setKeyValueAt(1.0, end->position());
        mPositionAnimation.setEasingCurve(QEasingCurve::Linear);

        mScaleAnimation.setDuration(duration);
        mScaleAnimation.setKeyValueAt(0, QVector3D(start->scale().x(), start->scale().y(), 0));
        mScaleAnimation.setKeyValueAt(1, QVector3D(end->scale().x(), end->scale().y(), 0));
        mScaleAnimation.setEasingCurve(QEasingCurve::Linear);
    
    }
    
    ~HgAnimatedQuad()
    {
    }
    
    void start()
    {
        mPositionAnimation.start();
        mScaleAnimation.start();
    }
           
    void update()
    {
        mQuad->setPosition(mPositionAnimation.currentValue().value<QVector3D>());
        QVector3D scale = mScaleAnimation.currentValue().value<QVector3D>();
        mQuad->setScale(QVector2D(scale.x(), scale.y()));
    }
    
    HgQuad* mQuad;
    MyVectorAnimation mPositionAnimation;
    MyVectorAnimation mScaleAnimation;
};

HgMediaWallRenderer::HgMediaWallRenderer(HgMediaWallDataProvider* provider, 
    Qt::Orientation scrollDirection, bool coverflowMode) :
    mDataProvider(provider),
    mRenderer(NULL),
    mIndicatorRenderer(NULL),
    mRendererInitialized(false),
    mOrientation(scrollDirection),
    mNextOrientation(scrollDirection),
    mStateAnimationAlpha(0),
    mStateAnimationOnGoing(false),
    mAnimationAlpha(0),
    mOpeningAnimationDuration(500),
    mOpenedItem(-1),
    mFlipAngle(qreal(360)),
    mZoomAmount(qreal(0.5)),
    mCoverflowMode(coverflowMode),
    mRowCount(1),
    mNextRowCount(1),
    mStateAnimationDuration(300),
    mStep(1.1),
    mZfar(-2),
    mSpacing2D(10,10),
    mImageSize2D(100, 60),
    mCameraDistance(0),
    mCameraRotationY(0),
    mCameraRotationZ(0),
    mFrontCoverElevation(0.4),
    mReflectionsEnabled(true),
    mItemCountChanged(false),
    mOpenedItemState(ItemClosed),
    mFrontItemPosition(0,0),
    mFrontItemPositionSet(false)    
{
    createStateMachine();
    mImageFader = new HgImageFader();    
    mRenderer = new HgVgQuadRenderer(256);
    mRendererInitialized = true;
    if (mCoverflowMode) {
        mOrientation = Qt::Horizontal;
        mNextOrientation = mOrientation;
    }
}

HgMediaWallRenderer::~HgMediaWallRenderer()
{
    delete mRenderer;
    delete mImageFader;
    delete mStateMachine;
}


void HgMediaWallRenderer::setCameraDistance(qreal distance)
{
    mCameraDistance = distance;
}

void HgMediaWallRenderer::setCameraRotationY(qreal angle)
{
    mCameraRotationY = angle;
}

void HgMediaWallRenderer::setCameraRotationZ(qreal angle)
{
    mCameraRotationZ = angle;
}

qreal HgMediaWallRenderer::getCameraDistance() const
{
    return mCameraDistance;
}

qreal HgMediaWallRenderer::getCameraRotationY() const
{
    return mCameraRotationY;
}

qreal HgMediaWallRenderer::getCameraRotationZ() const
{
    return mCameraRotationZ;
}

void HgMediaWallRenderer::draw(
    const QPointF& startPosition,
    const QPointF& position, 
    const QPointF& targetPosition, 
    qreal springVelocity,
    QPainter* painter)
{
    // if still not initialized we cant draw anything
    if (!mRendererInitialized)
        return;
        
    if (mOrientation != mNextOrientation ||
        mRowCount != mNextRowCount)
    {
                
        // save old state of the quads         
        recordState(mOldState);
        
        // goto wanted orientation / rowcount
        mOrientation = mNextOrientation;
        mRowCount = mNextRowCount;
        setImageSize(mNextImageSize);
        
        // setup quads to new state
        setupRows(startPosition, position, targetPosition, springVelocity, painter);

        // record state for animation
        recordState(mNextState);

        startStateAnimation(painter);
    }
    else
    {
        if (!mStateAnimationOnGoing)
        {
            setupRows(startPosition, position, targetPosition, springVelocity, painter);
        }
        else
        {
            setupStateAnimation(painter);
        }    
    }
    
    updateCameraMatrices();
    drawQuads(painter);
}

void HgMediaWallRenderer::setupRows(const QPointF& startPosition,
    const QPointF& position, 
    const QPointF& targetPosition, 
    qreal springVelocity,
    QPainter* painter)
{
    // draw the state for it 
    resetQuads();
    updateSpacingAndImageSize();
    
    if (mCoverflowMode)
    {
        //setupRow(startPosition, position, targetPosition, springVelocity, painter, 0);
        setupCoverflow(startPosition, position, targetPosition, springVelocity, painter);
    }
    else
    {
        if (mOrientation == Qt::Vertical)
        {
            setupGridPortrait(startPosition, position, targetPosition, 
              springVelocity, painter);            
        }
        else
        {
            setupGridLandscape(startPosition, position, targetPosition, 
                springVelocity, painter);
        }
    }        
}

void HgMediaWallRenderer::setFlipAnimationAngle(qreal angleInDegrees)
{
    mFlipAngle = angleInDegrees;
}
    
void HgMediaWallRenderer::setOpeningAnimationType(HgMediaWallRenderer::OpeningAnimationType type)
{
    mOpeningAnimationType = type;
}

void HgMediaWallRenderer::setOpeningAnimationDuration(int msecs)
{
    mOpeningAnimationDuration = msecs;
}

qreal HgMediaWallRenderer::animationAlpha() const
{
    return mAnimationAlpha;
}

void HgMediaWallRenderer::setAnimationAlpha(qreal alpha)
{
    mAnimationAlpha = alpha;
    
    if (mOpenedItemState == ItemClosing && alpha == 0.0f)
        mOpenedItemState = ItemClosed;
    
    if (mOpenedItemState == ItemOpening && alpha == 1.0f)
        mOpenedItemState = ItemOpened;
    
    emit renderingNeeded();
}

qreal HgMediaWallRenderer::stateAnimationAlpha() const
{
    return mStateAnimationAlpha;
}

void HgMediaWallRenderer::setStateAnimationAlpha(qreal alpha)
{
    mStateAnimationAlpha = alpha;
    if (alpha == 1 && mStateAnimationOnGoing)
    {
        mStateAnimationOnGoing = false;
    }
    emit renderingNeeded();
}

void HgMediaWallRenderer::createStateMachine()
{
    mStateMachine = new QStateMachine(this);
    mStateMachine->setAnimated(true);
    
    QState* root = new QState(QState::ParallelStates);
    QState* p1 = new QState(root);
    QState* p2 = new QState(root);
    
    // create idle/opened states
    {            
        QState* idle = new QState(p1);
        QState* opened = new QState(p1);

        idle->assignProperty(this, "animationAlpha", qreal(0));                                
        opened->assignProperty(this, "animationAlpha", qreal(1));

        // add opening animation
        QPropertyAnimation* anim1 = new QPropertyAnimation(this, "animationAlpha");
        anim1->setDuration(mOpeningAnimationDuration);
        idle->addTransition(this, SIGNAL(toggleItem()), opened)->addAnimation(anim1);
            
        // add closing animation
        QPropertyAnimation* anim2 = new QPropertyAnimation(this, "animationAlpha");
        anim2->setDuration(mOpeningAnimationDuration);
        opened->addTransition(this, SIGNAL(toggleItem()), idle)->addAnimation(anim2);

        QObject::connect(idle, SIGNAL(entered()), this, SLOT(onIdleState()));
        QObject::connect(opened, SIGNAL(entered()), this, SLOT(onOpenedState()));
    
        p1->setInitialState(idle);
    }
    
    // create two states to animate between
    {
        QState* s1 = new QState(p2);
        QState* s2 = new QState(p2);

        s1->assignProperty(this, "stateAnimationAlpha", qreal(0));
        s2->assignProperty(this, "stateAnimationAlpha", qreal(0));
        
        QPropertyAnimation* anim = new QPropertyAnimation(this, "stateAnimationAlpha");
        anim->setStartValue(qreal(0));
        anim->setEndValue(qreal(1));
        anim->setDuration(mStateAnimationDuration);
        
        s1->addTransition(this, SIGNAL(toggleState()), s2)->addAnimation(anim);
        s2->addTransition(this, SIGNAL(toggleState()), s1)->addAnimation(anim);        

        p2->setInitialState(s1);        
    }

    root->setInitialState(p1);
    mStateMachine->addState(root);    
    mStateMachine->setInitialState(root);
    mStateMachine->start();

}

void HgMediaWallRenderer::onIdleState()
{
    emit itemClosed(mOpenedItem);
}

void HgMediaWallRenderer::onOpenedState()
{
    emit itemOpened(mOpenedItem);
}

void HgMediaWallRenderer::setOrientation(Qt::Orientation orientation, bool animate)
{
    // coverflow is always horizontal
    if (mCoverflowMode)
    {
        mOrientation = Qt::Horizontal;
        mNextOrientation = mOrientation;
        return;
    }
    
    if (mOrientation != orientation)
    {
        mStateMachine->setAnimated(animate);
        mNextOrientation = orientation;

        if (!animate)
            mOrientation = orientation;
        else
        {
            emit renderingNeeded();            
        }
    }
}

Qt::Orientation HgMediaWallRenderer::getOrientation() const
{
    return mOrientation;
}

void HgMediaWallRenderer::drawQuads(QPainter* painter)
{
    
    mRenderer->transformQuads(mViewMatrix, mProjMatrix, mRect);

    mRenderer->drawQuads(mRect, painter);    
}


void HgMediaWallRenderer::enableCoverflowMode(bool enabled)
{
    mCoverflowMode = enabled;
}

bool HgMediaWallRenderer::coverflowModeEnabled() const
{
    return mCoverflowMode;
}

void HgMediaWallRenderer::setRowCount(int rowCount, const QSizeF& newImageSize, bool animate)
{
    if (rowCount != mRowCount)
    {
        mStateMachine->setAnimated(animate);

        mNextRowCount = rowCount;
        mNextImageSize = newImageSize;

        mColumnCount = rowCount;
        
        if (!animate)
        {
            mRowCount = rowCount;
        }
        else
        {
            emit renderingNeeded();            
        }
         
    }

}

int HgMediaWallRenderer::getRowCount() const
{
    return mRowCount;
}

void HgMediaWallRenderer::recordState(HgMediaWallRenderer::State& state)
{
    // cleanup old quads
    for (int i = 0; i < state.mQuads.size(); i++)
    {
        delete state.mQuads[i];
    }
    
    state.mQuads.clear();
    
    // record new quads
    for (int i = 0; i < mRenderer->quadCount(); i++)
    {
        HgQuad* quad = mRenderer->quad(i);
        if (!quad->visible())
            continue;
        
        state.mQuads.append(quad->copy());
    }    
}

void HgMediaWallRenderer::setupStateAnimation(QPainter* painter)
{
    Q_UNUSED(painter)
    
    resetQuads();
    // setup quads from animated state
    for (int i = 0; i < mOldState.mQuads.size(); i++)
    {
        mAnimatedQuads[i]->update();
        mRenderer->quad(i)->copyFrom(*mOldState.mQuads[i]);
    }
}

void HgMediaWallRenderer::resetQuads()
{
    for (int i = 0; i < mRenderer->quadCount(); i++)
        mRenderer->quad(i)->setVisible(false);    
}

HgQuad* HgMediaWallRenderer::getQuadAt(const QPointF& position) const
{
    if (!mRendererInitialized)
        return NULL;
        
    return mRenderer->getQuadAt(position);//mapFromWindow(position));
}

bool HgMediaWallRenderer::isItemOpen() const
{
    return (mOpenedItem != -1 && mAnimationAlpha > 0);
}

void HgMediaWallRenderer::setRect(const QRectF& windowRect)
{
    mRect = windowRect;
}

const QRectF& HgMediaWallRenderer::getRect() const
{
    return mRect;
}

void HgMediaWallRenderer::updateCameraMatrices()
{    
    QMatrix4x4 view;
        
    view.setToIdentity();
    
    view.lookAt(QVector3D(0.0, 0.0, 1.0f  + mCameraDistance), 
        QVector3D(0.0f, 0.0f, 0.0f), QVector3D(0.0f, 1.0f, 0.0f));

    QMatrix4x4 rot;
    rot.rotate(mCameraRotationZ, QVector3D(0,0,1));
    rot.rotate(mCameraRotationY, QVector3D(0,1,0));
    view *= rot;
        
    qreal aspect = mRect.width() / mRect.height();
    
    QMatrix4x4 proj;
    proj.setToIdentity();
    
    if (mRect.width() <= mRect.height())
    {
        qreal aspect = mRect.height() / mRect.width();
        proj.frustum(-0.5f, 0.5f, -0.5f*aspect, 0.5f*aspect, 1.0f, 1000.0f);
    }
    else
    {
        qreal aspect = mRect.width() / mRect.height();
        proj.frustum(-0.5f*aspect, 0.5f*aspect, -0.5f, 0.5f, 1.0f, 1000.0f);
    }

    mViewMatrix = view;
    mProjMatrix = proj;

    qreal mirrorPlaneY;
    if (mCoverflowMode)
    {
        mirrorPlaneY = -mImageSize3D.height()/2;
    }
    else // grid
    {
        mirrorPlaneY = getRowPosY(mRowCount-1)-mImageSize3D.height()/2;
    }

    mRenderer->setMirroringPlaneY(mirrorPlaneY);
}


void HgMediaWallRenderer::updateSpacingAndImageSize()
{
    qreal div = mRect.width() <= mRect.height() ? mRect.width() : mRect.height();
    
    mSpacing3D = mSpacing2D / div;
    mImageSize3D = mImageSize2D / div;
}

void HgMediaWallRenderer::setSpacing(const QSizeF& spacing)
{
    mSpacing2D = spacing;
}

void HgMediaWallRenderer::setImageSize(const QSizeF& imageSize)
{
    mImageSize2D = imageSize;
    mNextImageSize = imageSize;
}

const QSizeF& HgMediaWallRenderer::getSpacing() const
{
    return mSpacing2D;
}

const QSizeF& HgMediaWallRenderer::getImageSize() const
{
    return mImageSize2D;
}

void HgMediaWallRenderer::setFrontCoverElevationFactor(qreal elevation)
{
    mFrontCoverElevation = elevation;
}

qreal HgMediaWallRenderer::getFrontCoverElevationFactor() const
{
    return mFrontCoverElevation;
}

void HgMediaWallRenderer::openItem(int index, bool animate)
{
    if (isItemOpen())
        return;
    
    mOpenedItem = index;
    mOpenedItemState = animate ? ItemOpening : ItemOpened;

    mStateMachine->setAnimated(animate);
    emit toggleItem();
    
}

void HgMediaWallRenderer::closeItem(bool animate)
{
    if (!isItemOpen())
        return;

    mOpenedItemState = animate ? ItemClosing : ItemClosed;
    if (!animate)
        mOpenedItem = -1;

    mStateMachine->setAnimated(animate);
    emit toggleItem();
}

qreal HgMediaWallRenderer::getRowPosY(int row)
{
    qreal step = mSpacing3D.height() + mImageSize3D.height();            
    return mRowCount == 1 ? qreal(0) : (((qreal)mRowCount/qreal(2)-qreal(0.5)) - (qreal)row) * step; 
}

qreal HgMediaWallRenderer::getColumnPosX(int col)
{
    qreal step = -(mSpacing3D.width() + mImageSize3D.width());                
    return mColumnCount == 1 ? qreal(0) : (((qreal)mColumnCount/qreal(2)-qreal(0.5)) - (qreal)col) * step; 
}


void HgMediaWallRenderer::enableReflections(bool enabled)
{
    mReflectionsEnabled = enabled;
}

bool HgMediaWallRenderer::reflectionsEnabled() const
{
    return mReflectionsEnabled;
}
    
QPointF HgMediaWallRenderer::mapFromWindow(const QPointF& point) const
{
    return QPointF(point.x(), mRect.height() - point.y());
}

void HgMediaWallRenderer::emitUpdate()
{
    emit renderingNeeded();
}

void HgMediaWallRenderer::applyOpeningAnimation(HgQuad* quad)
{
    QQuaternion rot(0,0,0,1);
    qreal rotAngle = mAnimationAlpha * mFlipAngle;
    rot = QQuaternion::fromAxisAndAngle(QVector3D(0,1,0), rotAngle);
    quad->setRotation(rot);
    quad->setPosition(quad->position() + QVector3D(0,0,mAnimationAlpha * mZoomAmount));    
}


qreal HgMediaWallRenderer::getWorldWidth() const
{   
    qreal width = ceil((qreal)mDataProvider->imageCount() / (qreal)mRowCount - 1.0f);
    
    // if we are in vertical orientation we want last and first item
    // to place at the top and bottom of the screen instead of center
    if (mOrientation == Qt::Vertical)
    {
        qreal step = mSpacing2D.height() + mImageSize2D.height(); 
        width -= (mRect.height() / step - 1.0f);
    }
       
    return width;
}

void HgMediaWallRenderer::beginRemoveRows(int start, int end)
{
    mRemoveStart = start;
    mRemoveEnd = end;
    mItemCountChanged = true;
    
    recordState(mOldState);

}

void HgMediaWallRenderer::endRemoveRows()
{
        
    mStateMachine->setAnimated(true);

    emit renderingNeeded();            
    
}

void HgMediaWallRenderer::startStateAnimation(QPainter* painter)
{
    
    // clear previous animation quads
    for (int i = 0; i < mAnimatedQuads.size(); i++)
    {
        delete mAnimatedQuads[i];
    }        
    mAnimatedQuads.clear();
    
    // setup animated quads
    HgQuad* defaultQuad = new HgQuad();
    defaultQuad->setPosition(QVector3D(100,100,-100));
    int n = mOldState.mQuads.count() < mNextState.mQuads.count() ? mNextState.mQuads.count() : mOldState.mQuads.count();
    for (int i = 0; i < n; i++)
    {
        HgQuad* qA = (i >= mOldState.mQuads.count()) ? defaultQuad : mOldState.mQuads[i];
        HgQuad* qB = (i >= mNextState.mQuads.count()) ? defaultQuad : mNextState.mQuads[i];
        
        HgAnimatedQuad* q = new HgAnimatedQuad(qA, qB, mStateAnimationDuration);
        mAnimatedQuads.append(q);
        q->start();
    }
    
    mStateAnimationOnGoing = true;
    
    // setup first frame of the animation
    setupStateAnimation(painter);        

    // toggle state animation on
    toggleState();

}

void HgMediaWallRenderer::setupCoverflow(const QPointF& startPosition,
    const QPointF& position, 
    const QPointF& targetPosition, 
    qreal springVelocity,
    QPainter* painter)
{   
    Q_UNUSED(startPosition)
    Q_UNUSED(targetPosition)
    Q_UNUSED(springVelocity)
    Q_UNUSED(painter)
    
    // save selected item for coverflow
    mSelectedItem = ceil(position.x());
    
    int quadsVisible = (mRect.width() / mImageSize2D.width() + 1) * 4;
    int selectedItemIndex = quadsVisible / 2;

    qreal step = mSpacing3D.width() + mImageSize3D.width();                
    qreal ipos = floorf(position.x());
    qreal frac = (position.x() - ipos) * step;
    qreal posX = -(qreal)(selectedItemIndex + 0) * step - frac;
    qreal zFar = -mFrontCoverElevation;
    qreal posY = 0;

    int count = mDataProvider->imageCount();
    int quadIndex = 0;
    int itemIndex = ((int)(ipos - (qreal)selectedItemIndex));
    int index = 0;
    
    while (1)
    {
        if (itemIndex < 0)
        {
            itemIndex++;
            posX += step;
            index++;
            continue;
        }
        else if (itemIndex >= count || index >= quadsVisible || quadIndex >= mRenderer->quadCount())
        {
            break;
        }
                        
        qreal posZ = zFar;

        // if this is center item modify its z
        qreal p = posX / step;
        if (p > -1.0f && p < 1.0f)
        {
            qreal d = lerp(-zFar, 0, qBound(qreal(0), qAbs(springVelocity)/6.0f, qreal(1)));
            posZ = zFar + sin((p+1.0f) * KPi / 2) * d;                
        }

        // modify z also for sorting
        posZ -= 0.001f * abs(posX/step);
                
        // setup quad for this item
        HgQuad* quad = mRenderer->quad(quadIndex);
        setupDefaultQuad(QVector3D(posX, posY, posZ), itemIndex, mReflectionsEnabled, quadIndex);
                         
        // step to next item                    
        posX += step;        
        itemIndex++;
        index++;
    }
    
}


void HgMediaWallRenderer::setupGridPortrait(const QPointF& startPosition,
    const QPointF& position, 
    const QPointF& targetPosition, 
    qreal springVelocity,
    QPainter* painter)
{
    Q_UNUSED(startPosition)
    Q_UNUSED(targetPosition)
    Q_UNUSED(springVelocity)
    Q_UNUSED(painter)
    
    int rowCount = (mRect.height() / mImageSize2D.height() + 1) * 4;
    int rowsUp = rowCount/2;
        
    qreal stepY = mSpacing3D.height() + mImageSize3D.height();
    qreal ipos = floorf(position.x());
    qreal frac = (position.x() - ipos) * stepY;
    qreal posY = -(qreal)rowsUp * stepY - frac;
        
    // adjust height so that we begin from top
    qreal div = mRect.width() <= mRect.height() ? mRect.width() : mRect.height();
    posY -= mRect.height() / div / 2.0 - stepY / 2.0;
    
    int count = mDataProvider->imageCount();
    int itemIndex = ((int)(ipos - (qreal)rowsUp)) * mColumnCount;
    int row = 0;
    int quadIndex = 0;
    
    while (1)
    {
        if (itemIndex < 0)
        {
            itemIndex+=mColumnCount;
            posY += stepY;
            row++;
            continue;
        }
        else if (itemIndex >= count || quadIndex >= mRenderer->quadCount() || row >= rowCount)
        {
            break;
        }
        
        setupGridRow(-posY, itemIndex, quadIndex);
                        
        posY += stepY;
        row++;
        itemIndex+=mColumnCount;
    }
    
}

void HgMediaWallRenderer::setupGridLandscape(const QPointF& startPosition,
    const QPointF& position, 
    const QPointF& targetPosition, 
    qreal springVelocity,
    QPainter* painter)
{
    Q_UNUSED(startPosition)
    Q_UNUSED(targetPosition)
    Q_UNUSED(springVelocity)
    Q_UNUSED(painter)
    
    int colCount = (mRect.width() / mImageSize2D.width() + 1) * 3;
    int colsLeft = colCount/2;

    qreal stepX = mSpacing3D.width() + mImageSize3D.width();
    qreal ipos = floorf(position.x());
    qreal frac = (position.x() - ipos) * stepX;
    qreal posX = -(qreal)colsLeft * stepX - frac;    
    
    int count = mDataProvider->imageCount();
    int itemIndex = ((int)(ipos - (qreal)colsLeft)) * mRowCount;
    int col = 0;
    int quadIndex = 0;
    
    while (1)
    {
        if (itemIndex < 0)
        {
            itemIndex+=mColumnCount;
            posX += stepX;
            col++;
            continue;
        }
        else if (itemIndex >= count || col >= colCount || quadIndex >= mRenderer->quadCount())
        {
            break;
        }
        
        setupGridColumn(posX, itemIndex, quadIndex);
                        
        posX += stepX;
        col++;
        itemIndex+=mRowCount;
    }
}

void HgMediaWallRenderer::setupGridColumn(qreal posX, int itemIndex, int& quadIndex)
{
    for (int i = 0; i < mRowCount; i++)
    {
        qreal posY = getRowPosY(i);
        
        // enable reflections for the last row needed
        bool reflections = (i == (mRowCount-1) && mReflectionsEnabled);

        setupDefaultQuad(QVector3D(posX, posY, 0), itemIndex++, reflections, quadIndex);
        
        if (itemIndex >= mDataProvider->imageCount())
            return;    
    }    
}

void HgMediaWallRenderer::setupGridRow(qreal posY, int itemIndex, int& quadIndex)
{
    for (int i = 0; i < mColumnCount; i++)
    {
        qreal posX = getColumnPosX(i);
        setupDefaultQuad(QVector3D(posX, posY, 0), itemIndex++, false, quadIndex);
        if (itemIndex >= mDataProvider->imageCount())
            return;     
    }    
}

void HgMediaWallRenderer::setupDefaultQuad(const QVector3D& pos, int itemIndex, bool reflectionsEnabled, int& quadIndex)
{
    HgQuad* quad = mRenderer->quad(quadIndex++);
    quad->setPosition(pos);
    quad->setImage(mDataProvider->image(itemIndex));
    quad->setVisible(true);
    quad->setScale(QVector2D(mImageSize3D.width(),mImageSize3D.height()));
    quad->setPivot(QVector2D(0,0));
    quad->setUserData(QVariant(itemIndex));
    quad->setRotation(QQuaternion(1,0,0,0));
    quad->setOuterRotation(QQuaternion(1,0,0,0));
    quad->enableMirrorImage(reflectionsEnabled);
    quad->setAlpha(1.0f);
    
    // apply opening animation if needed
 /*   if (itemIndex == mOpenedItem)
        applyOpeningAnimation(quad);
*/
    // setup indicator/decorator for the item if needed 
    int flags = mDataProvider->flags(itemIndex);
    const HgImage* indicatorImage = mDataProvider->indicator(flags);
    if (flags != 0 && indicatorImage)
    {
        HgQuad* indicator = mRenderer->quad(quadIndex++);
        setupIndicator(quad, indicator, indicatorImage, 
            itemIndex);
        indicator->enableMirrorImage(reflectionsEnabled);
    }


}

void HgMediaWallRenderer::setupIndicator(HgQuad* parent, 
    HgQuad* indicator, const HgImage* indicatorImage, int itemIndex)
{
    indicator->setPosition(parent->position()+
        QVector3D(0.25*mImageSize3D.width(), -0.25*mImageSize3D.height(), 0.0001f));
    indicator->setImage(indicatorImage);
    indicator->setVisible(true);
    indicator->setScale(QVector2D(0.25f*mImageSize3D.width(), 0.25f*mImageSize3D.height()));
    indicator->setPivot(QVector2D(0.0, 0.0));
    indicator->setUserData(QVariant(itemIndex));
    indicator->setRotation(parent->rotation());
    indicator->setOuterRotation(parent->outerRotation());
    indicator->enableMirrorImage(false);
    indicator->setAlpha(parent->alpha());

    // apply opening animation to indicator if needed
    if (itemIndex == mOpenedItem)
        applyOpeningAnimation(indicator);
}

HgQuadRenderer* HgMediaWallRenderer::getRenderer()
{
    return mRenderer;
}

bool HgMediaWallRenderer::getItemPoints(int index, QPolygonF& points) const
{
    QPolygonF poly;
    if (!mRenderer->getQuadTranformedPoints(poly, index))
        return false;
    
    points = poly;
    return true;
}

QList<HgQuad*> HgMediaWallRenderer::getVisibleQuads() const
{
    return mRenderer->getVisibleQuads(QRectF(0, 0, mRect.width(), mRect.height()));
}

void HgMediaWallRenderer::setFrontItemPosition(const QPointF& position)
{
    mFrontItemPosition = position;
    
    mRenderer->setTranslation(
        QVector2D(position.x(), position.y()));    
}

QPointF HgMediaWallRenderer::frontItemPosition() const
{
    return mFrontItemPosition;
}