/*

* 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:   glxzoomwidget.cpp

*               description of the class GlxGlxZoomWidget which controls the Zoom behavior of coverflow.

*

*/

#include <QPinchGesture>

#include <hbiconitem.h>

#include <QTimeLine>

#include <QGesture>

#include <hbinstance.h>

#include "glximagedecoderwrapper.h"

#include "glxmodelparm.h"

#include "glxzoomwidget.h"

const int MAXZVALUE = 100;

const int MINZVALUE = 0;

const int NOOFSTEPSZI = 24;

const int NOOFSTEPSZO = 18;

const float MAXDTZOOMIN = 3.5;

const int NO_OF_STEPS_FOR_SPRINGBACK_AT_MAX = 12;

const int NO_OF_STEPS_FOR_SPRINGBACK_AT_MIN = 5;

GlxZoomWidget::GlxZoomWidget(QGraphicsItem *parent):HbScrollArea(parent), 

            mModel(NULL), mMinZValue(MINZVALUE), 

            mMaxZValue(MAXZVALUE), mTimerId(0),

            mImageDecodeRequestSend(false), 

            mPinchGestureOngoing(false), mDecodedImageAvailable(false),

            mZoomOngoing(false)

{

    grabGesture(Qt::PinchGesture);

    grabGesture(Qt::TapGesture);

    setAcceptTouchEvents(true) ;

    setFrictionEnabled(true);

    setZValue(mMinZValue);

    //create the child items and background

    mZoomWidget = new QGraphicsWidget(this);

    mZoomItem = new QGraphicsPixmapItem(mZoomWidget);

    mZoomItem->setTransformationMode(Qt::SmoothTransformation);

    //the black background

    //replace when a proper substitute for setting backgrounds is known

    mBlackBackgroundItem = new HbIconItem(this);

    mBlackBackgroundItem->setBrush(QBrush(Qt::black));

    mBlackBackgroundItem->hide();

    //does not work so is commented

    //setBackgroundItem(mBlackBackgroundItem);

    //initializing the image decoder

    mImageDecoder = new GlxImageDecoderWrapper;

    setVerticalScrollBarPolicy(HbScrollArea::ScrollBarAlwaysOff);

    setHorizontalScrollBarPolicy(HbScrollArea::ScrollBarAlwaysOff);

	//AA: signal and slot to perform double tap animation

    //after every step redraw, signal is emitted to perform the next step

	connect( this, SIGNAL( stepZoom() ), this, SLOT( animateDoubleTap() ), Qt::QueuedConnection );

	mDoubleTap = false;

}

GlxZoomWidget::~GlxZoomWidget()

{

    //AA

    disconnect( this, SIGNAL( stepZoom() ), this, SLOT( animateDoubleTap()));

    //no Null checks required

    delete mZoomItem;

//    delete mZoomWidget; //as this is a content widegt it will automatically be deleted

    delete mBlackBackgroundItem;

    //reset the decoder to cancel pending tasks

    if(mImageDecoder) {

        resetDecoder();

        delete mImageDecoder;

    }

}

void GlxZoomWidget::resetDecoder()

{

        mImageDecoder->resetDecoder();

        mImageDecodeRequestSend = false;

        mDecodedImageAvailable = false;

}

void GlxZoomWidget::setModel (QAbstractItemModel *model)

{

    if(model)

    {

        mModel = model;

        retreiveFocusedImage(); //Update mZoomItem with focused Image

        connect( mModel, SIGNAL( destroyed() ), this, SLOT( modelDestroyed() ) );

    }

}

void GlxZoomWidget::setWindowSize(QSize windowSize)

{

    mWindowSize = windowSize;

    mBlackBackgroundItem->setGeometry(QRectF(QPointF(0,0), mWindowSize));

    //try to reset the max and min zoomed size here

    //In case the zoom widget is in background reset it

    if(!mZoomOngoing && mModel) {

        retreiveFocusedImage();

    }

    setZoomParams();

}

void GlxZoomWidget::forceZoomToBackground()

{

    mBlackBackgroundItem->hide();

    //push the widget back to background

    setZValue(mMinZValue);

    mZoomOngoing = false;

    emit zoomWidgetMovedBackground(mFocusIndex);

    //this actually resets the ZoomWidget and decoder

    if(mImageDecoder) {

        resetDecoder();

    }

    retreiveFocusedImage();

}

void GlxZoomWidget::indexChanged(int index)

{

    if(mFocusIndex != index) {

        resetDecoder();          //reset the decoder first to cancel pending tasks

        retreiveFocusedImage();  //Update mZoomItem with focused Image

    }

}

void GlxZoomWidget::cleanUp()

{

    disconnect(this,SIGNAL( pinchGestureReceived(int) ), this, SLOT( sendDecodeRequest(int) ) );

    if(mModel) {

        disconnect( mModel, SIGNAL( destroyed() ), this, SLOT( modelDestroyed() ) );

        mModel = NULL;

    }

    if(mImageDecoder) {

        resetDecoder();

    }

    mZoomItem->setPixmap(QPixmap());

	mBlackBackgroundItem->setParentItem(this);

}

void GlxZoomWidget::activate()

{

}

void GlxZoomWidget::setMinMaxZValue(int minZvalue, int maxZvalue)

{

    mMinZValue = minZvalue;

    mMaxZValue = maxZvalue;

}

void GlxZoomWidget::connectDecodeRequestToPinchEvent()

{

    connect(this,SIGNAL( pinchGestureReceived(int) ), this, SLOT( sendDecodeRequest(int) ), Qt::QueuedConnection );

}

bool GlxZoomWidget::sceneEvent(QEvent *event)

{

    bool consume(false);

    if (event->type() == QEvent::Gesture) {

        consume = executeGestureEvent(this, static_cast<QGestureEvent*>(event));

    }

    if(!consume)

    {

        consume = HbScrollArea::sceneEvent(event);

    }

    return consume;

}

bool GlxZoomWidget::sceneEventFilter(QGraphicsItem *watched,QEvent *event)

{

    qDebug( "GlxZoomWidget::sceneEventFilter enter event type %d ", event->type() );

    bool consume = false;

    if (event->type() == QEvent::Gesture) {

        consume = executeGestureEvent(watched, static_cast<QGestureEvent*>(event));

    }

    if(!consume) {

        consume = HbScrollArea::sceneEventFilter(watched,event);

    }

    return consume;

}

bool GlxZoomWidget::executeGestureEvent(QGraphicsItem *source,QGestureEvent *event)

{

         if(QTapGesture *gesture = static_cast<QTapGesture *>(event->gesture(Qt::TapGesture))) {        

            if (gesture->state() == Qt::GestureFinished) {

                if(!mTimerId) {

                    mTimerId = startTimer( DOUBLETAP_TIMEINTERVAL );

                }

            else {

                killTimer(mTimerId);

                mTimerId = 0;

                animateZoomOut(hbInstance->allMainWindows().first()->mapToScene(gesture->position().toPoint()));

            }

        }

        event->accept(gesture);

        return true;

    }

     if (QGesture *pinch = event->gesture(Qt::PinchGesture))  {

         if (isFocussedItemCorrupt()){

         return true;

         }

       QPinchGesture* pinchG = static_cast<QPinchGesture *>(pinch);

       QPinchGesture::ChangeFlags changeFlags = pinchG->changeFlags();

       if (changeFlags & QPinchGesture::ScaleFactorChanged) {

            mPinchGestureOngoing = true;

            mZoomOngoing = true;

            //retreive the gesture values

            qreal value = pinchG->scaleFactor() / pinchG->lastScaleFactor();

            QPointF center = pinchG->property("centerPoint").toPointF();

            //set the gesture center to the scene coordinates

            QPointF sceneGestureCenter = hbInstance->allMainWindows().first()->mapToScene(center.toPoint());

            zoomImage(value, sceneGestureCenter);

        }

       if (pinchG->state() == Qt::GestureStarted) {

           emit pinchGestureReceived(mFocusIndex);

           //bring the zoom widget to foreground

           if(zValue()!=mMaxZValue)

           {

            setZValue(mMaxZValue);

            //show the black background

            mBlackBackgroundItem->setParentItem(parentItem());

            mBlackBackgroundItem->setZValue(mMaxZValue - 1);

            mBlackBackgroundItem->show();

           }

       }

       if (pinchG->state() == Qt::GestureFinished) {

               //For giving a spring effect when user has zoomed more than normal.

		  mPinchGestureOngoing = false;               

        //scale the image to limited size

		if(mCurrentSize.width() > mMaxScaleDecSize.width() )

        {

        	  QPointF center(mWindowSize.width()/2, mWindowSize.height()/2);

		       m_AnimRefPoint = source->sceneTransform().map(center);

		       springEffectAtMax();

               return true;

		}

		if(mCurrentSize.width() < mMinDecScaleSize.width())

        {

              QPointF center(mWindowSize.width()/2, mWindowSize.height()/2);

              m_AnimRefPoint = source->sceneTransform().map(center);

              springEffectAtMin();

              return true;

               //do not reset the transform here as it will then zoom-in the widget to decoded image size

        }

        //finalize the transforms to the geometry else panning will not work

        finalizeWidgetTransform();

       }

       //gesture accepted

       return true;

     }

     //gesture rejected

     if(!mPinchGestureOngoing) {

         return false; 

     }

     return true;

}

void GlxZoomWidget::springEffectAtMax()

{

    //set the no. of steps for double tap animation 

    mdoubletapSteps = NO_OF_STEPS_FOR_SPRINGBACK_AT_MAX;

    //initiale variable for double tap animation

    mIncSF = 1;

    //For giving a spring effect when user has zoomed out more than normal.

    //Zoom out to mMaxScaleDecSize from the currentsize

    m_FinalAnimatedScaleFactor = mMaxScaleDecSize.width()/mCurrentSize.width();

    //calculate the step increment SF for each step

    msfInc = (1 - m_FinalAnimatedScaleFactor)/(mdoubletapSteps);

    //preserve the size when zoom out was initiated, requried for calculates applicable/req scale factor

    minitSize = mCurrentSize;

    animateDoubleTap();

}

void GlxZoomWidget::springEffectAtMin()

{

        m_FinalAnimatedScaleFactor = mMinDecScaleSize.width()/mCurrentSize.width();

        //set the no. of steps for double tap animation 

        mdoubletapSteps = NO_OF_STEPS_FOR_SPRINGBACK_AT_MIN;

        //initiale variable for double tap animation

        mIncSF = 1;

        //SF has to always greater than 1 for upscaling, hence range for zoomout is [1,m_FinalAnimatedScaleFactor]

        msfInc = (m_FinalAnimatedScaleFactor-1)/mdoubletapSteps;

        //preserve the size when zoom out was initiated, requried for calculates applicable/req scale factor

        minitSize = mCurrentSize;

        animateDoubleTap();

}

void GlxZoomWidget::zoomImage(qreal zoomFactor, QPointF center)

{

        // Pinch event filtering for very small zoom factors

    if (qAbs(1.0 - zoomFactor) < 0.007) {

        return;

    }

    adjustGestureCenter(center, zoomFactor);

    QSizeF requiredSize(mCurrentSize.width()*zoomFactor, mCurrentSize.height()*zoomFactor);

    limitRequiredSize(requiredSize);

    if(requiredSize != mCurrentSize) {

        QTransform zoomTransform = mZoomWidget->transform();

        QPointF transformedCenter = mZoomWidget->sceneTransform().inverted().map(center);

        zoomTransform.translate(transformedCenter.x(),transformedCenter.y());

        zoomTransform.scale(requiredSize.width()/mCurrentSize.width(), requiredSize.height()/mCurrentSize.height());

        zoomTransform.translate(-transformedCenter.x(),-transformedCenter.y());

        mZoomWidget->setTransform(zoomTransform);

        mCurrentSize = requiredSize;

    }

}

void GlxZoomWidget::limitRequiredSize(QSizeF &requiredSize)

{

    if(requiredSize.width() > mMaxScaleSize.width() ) {

        requiredSize = mMaxScaleSize ;

    }

    else if(requiredSize.width() < mMinScaleSize.width() ) {

        requiredSize = mMinScaleSize ;

    }

}

//makes sure that the gesture is on the screen center if the image is smaller than the screen

void GlxZoomWidget::adjustGestureCenter(QPointF & gestureCenter, qreal& zoomFactor)

{

    //clip zoom factor for pinch zoom. Double tap zoomfactor should never exceed

    //1.2 or 0.8 in any given step  

/*    if(zoomFactor > 1.2 )  {

        zoomFactor = 1.2;

    }

    if(zoomFactor < 0.7 )   {

        zoomFactor = 0.8;

    }*/

    qDebug("AA::adjustGestureCenter::ZoomFactor (%f)",zoomFactor);

    QPointF itemOriginPos = mZoomWidget->sceneTransform().map(QPointF(0,0)); 

    QPointF gesCenter = mZoomWidget->sceneTransform().map(gestureCenter); 

    //keep smaller image centered irrespective of zoomin or zoom out

    //note, only if the image is smaller than window size, else preserve the 

    //gesture center. Adjustments need to be done for both height/width

    //only one of them will be applicable, unless the image is smaller than

    //fullscreen size on both dimensions

    if( (mCurrentSize.width() <= mWindowSize.width()))  {

       //requires adjustment only in portrait orientation 

       if(mWindowSize.width() > mWindowSize.height())

           gestureCenter.setX(mWindowSize.width()/2);

    }

    //handle the case when CurrentSize is grater than window size

    //this applies to zoomout flow

    else  {

        //when the image is positioned beyond the left edge of the window

        //clamp the image to left edge

        if(itemOriginPos.x() >= 0) {

            gestureCenter.setX(itemOriginPos.x());    

        }

        //same applies when the image needs clamping on right edge

        else if(itemOriginPos.x()+ mCurrentSize.width() <= mWindowSize.width()){

            gestureCenter.setX(itemOriginPos.x() + mCurrentSize.width());

        }

        //else no clamping is required, theg esture center can be preserved

        //as is for the zoom step

   }

    //same logic applied for Y axis

    if( (mCurrentSize.height() <= mWindowSize.height())  )  {

        //requires adjustment only in landscape orientation

        if(mWindowSize.width() < mWindowSize.height())

                   gestureCenter.setY(mWindowSize.height()/2);

    }     

    else  {

            if(itemOriginPos.y() >= 0) {

               gestureCenter.setY(itemOriginPos.y());    

            }

            else if(itemOriginPos.y()+ mCurrentSize.height() <= mWindowSize.height()){

                gestureCenter.setY(itemOriginPos.y() + mCurrentSize.height());

            }

        }

    //special case for images that are smaller on both sides

    //centering of the gesture is important to prevent movement of the image

    //while zoom in or out

    if( (mCurrentSize.height() <= mWindowSize.height()) && (mCurrentSize.width() <= mWindowSize.width()) ) {

        gestureCenter.setX(mWindowSize.width()/2);

        gestureCenter.setY(mWindowSize.height()/2);

    }

    //reduce the ZF so as to show a decelerated effect at max/min levels

/*

    if(mCurrentSize.width() > mMaxScaleDecSize.width() && zoomFactor > 1 ) {

        zoomFactor = 1.0 + ((zoomFactor-1.0)/6) ;

    }

        if(mCurrentSize.width() < mMinDecScaleSize.width() && zoomFactor < 1 ) {

        zoomFactor = 1.0 - ((1.0-zoomFactor)/6) ;

    }

*/

}

//get the latest focused image and set it to mZoomItem

void GlxZoomWidget::retreiveFocusedImage()

{

    QPixmap targetPixmap(getFocusedImage());

    //initialize all the variables wrt the focussed pixmap

    mZoomWidget->resetTransform();

    mItemSize = targetPixmap.size();

    mMaxScaleSize = mItemSize;

    mMaxScaleSize.scale(mWindowSize*13, Qt::KeepAspectRatio);

    mMaxScaleDecSize = mItemSize;

    mMaxScaleDecSize.scale(mWindowSize*7, Qt::KeepAspectRatio);

    mMinScaleSize = mItemSize* 0.7;

    mMinDecScaleSize = mItemSize;

    QPointF originPos = sceneTransform().map(QPointF(0,0));

    mZoomWidget->setGeometry(QRectF(QPointF(mWindowSize.width()/2 - mItemSize.width()/2,mWindowSize.height()/2 - mItemSize.height()/2),mItemSize )); //chk this

    mZoomWidget->setPreferredSize(mItemSize);

    mZoomItem->setPixmap(targetPixmap);

    mCurrentSize = mItemSize;

    mStepCurrentSize = mItemSize;

    setContentWidget(mZoomWidget);

    show();

}

void GlxZoomWidget::dataChanged(QModelIndex startIndex, QModelIndex endIndex)

{

    if(mFocusIndex >= startIndex.row() && mFocusIndex <= endIndex.row()) {

        //get the latest image from the model

        //will replace a decoded image if callback is received after decoded image is received so a fix is required

        //retreiveFocusedImage();

        if(!mDecodedImageAvailable)  {

        QPixmap targetPixmap(getFocusedImage());

        mItemSize = targetPixmap.size();

        mMaxScaleSize = mItemSize;

        mMaxScaleSize.scale(mWindowSize*13, Qt::KeepAspectRatio);

        mMaxScaleDecSize = mItemSize;

        mMaxScaleDecSize.scale(mWindowSize*7, Qt::KeepAspectRatio);

        mMinScaleSize = mItemSize* 0.7;

        mMinDecScaleSize = mItemSize;

        mCurrentSize = mItemSize;

        mZoomItem->setPixmap(targetPixmap);

        finalizeWidgetTransform();

        }

    }

}

void GlxZoomWidget::modelDestroyed()

{

    mModel = NULL ;    

}

void GlxZoomWidget::indexChanged()

    {

    retreiveFocusedImage();

    }

void GlxZoomWidget::decodedImageAvailable()

{

    //new bitmap with better resolution is available

    //so set it to the item

    QPixmap decodedPixmap = mImageDecoder->getPixmap();

    disconnect(mImageDecoder, SIGNAL(pixmapDecoded()), this, SLOT(decodedImageAvailable()));

    if(decodedPixmap.isNull()){

        return;

    }

    mDecodedImageAvailable = true;

    mZoomItem->setPixmap(decodedPixmap);

    mItemSize = decodedPixmap.size();

    //this is important if not done then old transforms will be applied on the new image

    finalizeWidgetTransform();

}

void GlxZoomWidget::sendDecodeRequest(int index)

{

    if(!mImageDecodeRequestSend) {

        QString imagePath = (mModel->data(mModel->index(index,0),GlxUriRole)).value<QString>();

        mImageDecoder->decodeImage(imagePath);

        connect(mImageDecoder, SIGNAL(pixmapDecoded()), this, SLOT(decodedImageAvailable()));

        mImageDecodeRequestSend = true;

    }

}

void GlxZoomWidget::finalizeWidgetTransform()

{