/*

* 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: Juha Kauppinen, Mika Hokkanen

* 

* Description: Photo Browser

*

*/

#include "CDrawOneByOne.h"

#include "TextureLoader.h"

#include "DrawUtility.h"

#include "ImagicConsts.h"

#define IS_NOT_IN_ZOOM_ONEBYONE ((iDrawOneByOneTargetZoom) < (iContainer->KDoubleTapZoomOneByOne1 + 0.01f))

#define IS_ALMOST_ZERO (0.001)

const float CDrawOneByOne::KMaxMagGlassZoomFactor = 2.2;//2.0;

const float KOneByOneSlideSpeed = 0.24;

CDrawOneByOne::CDrawOneByOne(CImagicContainerBrowser* aContainer, TInt& aCurrentIndex):

    iContainer(aContainer)//,

    {

    iMagGlassOn = EFalse;

    iMagGlassOnPrev = EFalse;

    }

CDrawOneByOne::~CDrawOneByOne()

    {

    delete iMagGlass;

    }

CDrawOneByOne* CDrawOneByOne::NewLC(CImagicContainerBrowser* aContainer, TInt& aCurrentIndex)

    {

    CDrawOneByOne* self = new (ELeave) CDrawOneByOne(aContainer, aCurrentIndex);

    CleanupStack::PushL(self);

    self->ConstructL(aContainer, aCurrentIndex);

    return self;

    }

CDrawOneByOne* CDrawOneByOne::NewL(CImagicContainerBrowser* aContainer, TInt& aCurrentIndex)

    {

    CDrawOneByOne* self = CDrawOneByOne::NewLC(aContainer, aCurrentIndex);

    CleanupStack::Pop(); // self;

    return self;

    }

void CDrawOneByOne::ConstructL(CImagicContainerBrowser* aContainer, TInt& aCurrentIndex)

    {

    iMagGlass = CDrawMagGlass::NewL(iContainer, this);

    }

float CDrawOneByOne::GetMovingStep()

    {

    //iMovingStep = 0.01/(iDrawOneByOneZoom/8.0);

    iMovingStep = 0.015/(iDrawOneByOneZoom/8.0);

    return iMovingStep;

    }

float CDrawOneByOne::GetImgeFlowLocation()

    {

    return iOneByOneFlow;

    }

void CDrawOneByOne::SetImgeFlowLocation(float aValue)

    {

    iOneByOneFlow = aValue;

    }

TDrawOneByOneXY CDrawOneByOne::GetDrawOneByOneXY()

    {

    return iDrawOneByOneXY;

    }

TDrawOneByOneXY CDrawOneByOne::GetDrawOneByOneTargetXY()

    {

    return iDrawOneByOneTargetXY;

    }

void CDrawOneByOne::SetDrawOneByOneTargetXY(TDrawOneByOneXY aValue)

    {

    iDrawOneByOneTargetXY = aValue;

    }

void CDrawOneByOne::ChangeDrawOneByOneTargetX(float aValue)

    {

    iDrawOneByOneTargetXY.iX += aValue;

    }

void CDrawOneByOne::ChangeDrawOneByOneTargetY(float aValue)

    {

    iDrawOneByOneTargetXY.iY += aValue;

    }

float CDrawOneByOne::GetDrawOneByOneZoom()

    {

    return iDrawOneByOneZoom;

    }

void CDrawOneByOne::SetDrawOneByOneZoom(float aValue)

    {

    iDrawOneByOneZoom = aValue;

    }

float CDrawOneByOne::GetDrawOneByOneTargetZoom()

    {

    return iDrawOneByOneTargetZoom;

    }

void CDrawOneByOne::SetDrawOneByOneTargetZoom(float aValue)

    {

    iDrawOneByOneTargetZoom = aValue;

    }

float CDrawOneByOne::GetDrawOneByOneWidth()

    {

    return iDrawOnebyOneW;

    }

void CDrawOneByOne::SetDrawOneByOneWidth(float aValue)

    {

    iDrawOnebyOneW = aValue;

    }

float CDrawOneByOne::GetDrawOneByOneHeight()

    {

    return iDrawOnebyOneH;

    }

void CDrawOneByOne::SetDrawOneByOneHeight(float aValue)

    {

    iDrawOnebyOneH = aValue;

    }

TBool CDrawOneByOne::IsMagGlassOn()

    {

    return iMagGlassOn;

    }

void CDrawOneByOne::SetMagGlassStatus(TBool aValue)

    {

    iMagGlassOn = aValue;

    iMagGlass->InitDrawMagGlass();

    }

TBool CDrawOneByOne::IsMagGlassPrevStateOn()

    {

    return iMagGlassOnPrev;

    }

void CDrawOneByOne::SetMagGlassPrevStatus(TBool aValue)

    {

    iMagGlassOnPrev = aValue;

    }

CDrawMagGlass* CDrawOneByOne::GetMagGlass()

    {

    return iMagGlass;

    }

void CDrawOneByOne::KeyPressed()

    {

    iMenuAlpha = 1;

    }

void CDrawOneByOne::KeyReleased()

    {

    iMenuAlpha = 0.99;

    }

void CDrawOneByOne::KeyEvent()

    {

    //iMenuAlpha = 1;

    }

/*----------------------------------------------------------------------*/

// Initializes one by one view

//

void CDrawOneByOne::InitDrawOnebyOne(TReal aDrawZoom, TReal aInPictureX, TReal aInPictureY)

    {

    DP0_IMAGIC(_L("CDrawOneByOne::InitDrawOnebyOne"));

    //iDrawOneByOneXY.iX = 0;

    //iDrawOneByOneXY.iY = 0;

    iDrawOneByOneXY.iX = aInPictureX;

    iDrawOneByOneXY.iY = aInPictureY;

    iDrawOneByOneTargetXY.iX = 0;

    iDrawOneByOneTargetXY.iY = 0;

    //iDrawOneByOneZoom = 0.1;

    //if(aDrawZoom == 1)

        iDrawOneByOneZoom = aDrawZoom;

    /*else

        iDrawOneByOneZoom = 0.4;*/

    iDrawOneByOneTargetZoom = 1;

    TSize size = iContainer->Size();

    iContainer->CalculateImageSize(iDrawOnebyOneW, iDrawOnebyOneH, (float)size.iWidth/(float)size.iHeight);

    iZoomingStep = 0.1 * iDrawOneByOneTargetZoom;

    iZoomingSpeed = 0.2; // unno 2.5*iTimeDiff;

    iScalingSpeed = 0.3;

    iOneByOneFlow = 0;

    iMagGlassOn = EFalse;

    iMagGlassOnPrev = EFalse;

#ifdef HOLD_SELECTION_ONDRAG

    iContainer->iOneByOneSlideByDrag = EFalse;

#endif

    iBorder = 0.03;

    iScreenW = 0;

    iScreenH = 0;

    iInPictureX = 0;

    iInPictureY = 0;

    //iContainer->iDrawFunction = CImagicContainerBrowser::EOneByOne;

    iContainer->SetDrawMode(CImagicContainerBrowser::EOneByOne);

    iContainer->iKeyPressedDown=EFalse;

    //iContainer->iZoomInKey=EFalse;

    //iContainer->iZoomOutKey=EFalse;

    iMagGlass->InitDrawMagGlass();

    }

/*----------------------------------------------------------------------*/

//Draws one by one view

// 

void CDrawOneByOne::DrawOnebyOneL(const TSize &aSize)

    {

    DP0_IMAGIC(_L("CDrawOneByOne::DrawOnebyOne"));

    //RDebug::Print(_L("CDrawOneByOne::DrawOnebyOne"));

    CImageData* imageData = iContainer->iIEngine->GetImageData(iContainer->GetCurrentIndex());

    // Calculate screen size

    iContainer->CalculateImageSize(iImageWidth, iImageHeight, (float)aSize.iWidth/(float)aSize.iHeight);

    //Interpolate current screen size into the new one

    //if(iContainer->iLastEventFromKeys)

        {

        iContainer->Interpolate(iDrawOnebyOneW, iImageWidth, 0.55);

        iContainer->Interpolate(iDrawOnebyOneH, iImageHeight, 0.55);

        }

    /*else//faster interpolation for touch bcos slide speed is also faster

        {

        iContainer->Interpolate(iDrawOnebyOneW, iImageWidth, 0.85);

        iContainer->Interpolate(iDrawOnebyOneH, iImageHeight, 0.85);  

        }*/

    //iContainer->Interpolate(iDrawOnebyOneW, iImageWidth, 0.55);

    //iContainer->Interpolate(iDrawOnebyOneH, iImageHeight, 0.55);

    //Use orthogonal projection in OneByOne mode

    glLoadIdentity();

    glOrthof(-iDrawOnebyOneW, iDrawOnebyOneW, -iDrawOnebyOneH, iDrawOnebyOneH, -1,1);

    //iContainer->Interpolate(iContainer->iDisplayRotation, iContainer->iDisplayRotationTarget, 0.2);

    float tmp = iContainer->GetDisplayRotAngle();

    iContainer->Interpolate(tmp, iContainer->GetDisplayRotTargetAngle(), 0.2);

    iContainer->SetDisplayRotAngle(tmp);

    glRotatef(iContainer->GetDisplayRotAngle(), 0,0,1);

    // Handle keys----------------------->

    HandleMovingKeysOnebyOne();

    // Calculate picture size

    iContainer->CalculateImageSize(iImageWidth, iImageHeight, imageData->GetAspectRatio());

    //Here we check that we do not go over the picture boundaries

    CheckImageLocation();

    //Move in picture------------------------>

    iDrawOneByOneTargetXY.iX = iInPictureX / iDrawOneByOneTargetZoom;

    iDrawOneByOneTargetXY.iY = iInPictureY / iDrawOneByOneTargetZoom;

    //iMovingStep = 0.01/(iDrawOneByOneZoom/8);

    iContainer->Interpolate(iDrawOneByOneXY.iX,iDrawOneByOneTargetXY.iX, iMovingSpeed);

    iContainer->Interpolate(iDrawOneByOneXY.iY,iDrawOneByOneTargetXY.iY, iMovingSpeed);

    // Zooming-------------------------------->

    if(iContainer->iKeyPressedDown)

        {

        if(iContainer->GetKeyData().iZoomInKey)

            iDrawOneByOneTargetZoom += iZoomingStep*2;//zoom in

        else if(iContainer->GetKeyData().iZoomOutKey)

            iDrawOneByOneTargetZoom -= iZoomingStep*4;//zoom out

        }

    //Limit zooming range

    iContainer->CheckLimits(iDrawOneByOneTargetZoom, CImagicContainerBrowser::KMinOneByOneZoom, CImagicContainerBrowser::KMaxOneByOneZoom);

    // Interpolate to new zoom value

    if(iDrawOneByOneZoom < 0.99)

        iContainer->Interpolate(iDrawOneByOneZoom, iDrawOneByOneTargetZoom, iScalingSpeed);

    else

        iContainer->Interpolate(iDrawOneByOneZoom, iDrawOneByOneTargetZoom, iZoomingSpeed);

    // Rotation

    iContainer->HandleRotationKeys();

    iContainer->HandleRotation(imageData->iGridData.iRotationAngle, imageData->iGridData.iTargetRotationAngle);

    //Load image ----------------------------------->

    // Load high res picture if possible

    //if(iOneByOneFlow < IS_ALMOST_ZERO)//when not zero, images are moving

    if(iOneByOneFlow == 0)//when not zero, images are moving in oneByOne flow

        {

        iContainer->LoadHighResImage(imageData, iContainer->GetCurrentIndex());

        }

    //Bind and Draw ------------------------------------->

    //Bind to Grid low res texture index. If high res is not available, so we have always some picture to bind and draw it

    // Determine image indexes, -1 means no image

    TInt imageIndexes[3]={-1,iContainer->GetCurrentIndex(),-1};

    //Do not draw other images when not sliding and we are in zoomed into picture

    //if(iOneByOneFlow != 0)//when not zero, images are moving    

    //if(!iMagGlassOn || IS_NOT_IN_ZOOM_ONEBYONE)

        {

        if (iContainer->GetCurrentIndex()>0)

            imageIndexes[0]=iContainer->GetCurrentIndex()-1;

        if (iContainer->GetCurrentIndex() < iContainer->iIEngine->GetTotalNumOfImages()-1)

            imageIndexes[2]=iContainer->GetCurrentIndex()+1;

        }

    //Fade side images when flow goes 70% of image width

    if(Abs(iOneByOneFlow) > 0.25)

        {

        iFadeColor=1;

        glColor4f(iFadeColor,iFadeColor,iFadeColor, 1);

        }

    if(iOneByOneFlow < 0.5)

        {

        //if(iContainer->iLastEventFromKeys)

            iContainer->Interpolate(iFadeColor, 0, 0.25);

        /*else

            iContainer->Interpolate(iFadeColor, 0, 0.35);*/

        glColor4f(iFadeColor,iFadeColor,iFadeColor, 1);

        }

    /*if(iFadeColor == 0)

        {

        // Determine image indexes, -1 means no image

        TInt imageIndexes[3]={-1,iContainer->GetCurrentIndex(),-1};

        }*/

    //Move to zero coordinate, which is selected image coordinate

#ifdef HOLD_SELECTION_ONDRAG

    //Stop interpolation when user is dragging

    if(iContainer->iHoldSelection == EFalse)

        {

#endif

        if(iContainer->iLastEventFromKeys)

            iContainer->Interpolate(iOneByOneFlow, 0, KOneByOneSlideSpeed);//sliding speed

        else

            iContainer->Interpolate(iOneByOneFlow, 0, KOneByOneSlideSpeed*1.3);//sliding speed

        }

    //glColor4f(1,1,1, 1);

    glPushMatrix();

    glScalef(iDrawOneByOneZoom, iDrawOneByOneZoom, iDrawOneByOneZoom);

    //Move to first image location (= current-1)

    glTranslatef(iOneByOneFlow-iContainer->KOneByOneSpacing,0,0);

    TInt currentIndexTexture=0;

    for(TInt i=0; i<3; i++)

        {

        // Check that image index is valid

        if (imageIndexes[i]!=-1)

            {

            //Bind to best picture

            CImageData* data=iContainer->iIEngine->GetImageData(imageIndexes[i]);

            if(i==1)

                {

                iContainer->iCurrentBindedIndex = data->iGridData.BestImage();

                //Bind to 512 res image when not zoomed for better image scaling quality

                if(IS_NOT_IN_ZOOM_ONEBYONE && data->iGridData.iGlHQ512TextIndex!=0 && !iMagGlassOn) 

                    iContainer->iCurrentBindedIndex = data->iGridData.iGlHQ512TextIndex;

                }

            //Side images gets only 128x128 tn because of perf reason

            else

                iContainer->iCurrentBindedIndex = data->iGridData.iGlLQ128TextIndex;

            if(!iContainer->iCurrentBindedIndex)

                iContainer->iCurrentBindedIndex = data->iGridData.iGlLQ32TextIndex;

            //If no images ready, bind with loading tn

            if (iContainer->iCurrentBindedIndex == 0)

                iContainer->iCurrentBindedIndex = iContainer->iLoadingTextureIndex;

            glBindTexture(GL_TEXTURE_2D, iContainer->iCurrentBindedIndex);

            if(i==1){

                currentIndexTexture=iContainer->iCurrentBindedIndex;

            }

            iContainer->SetMinMagFilterLinearDo(iContainer->iMinMagFilterSetting);

            //Store matrix and rotate picture

            glPushMatrix();

            if(i==1 && iMagGlassOn)

                {

                glColor4f(1,1,1, 1);

                glTranslatef(iDrawOneByOneXY.iX, -iDrawOneByOneXY.iY, 0);

                glRotatef(data->iGridData.iRotationAngle, 0,0,1);

                iMagGlass->DrawMagGlass(aSize, data->GetAspectRatio());

                }

            else

                {

                //Set Draw color to white when drawing selection or if we drag images 

                if(i==1 || (iContainer->iHoldSelection && !iMagGlassOn))

                    glColor4f(1,1,1, 1);

                else//othervise "fade" images

                    glColor4f(iFadeColor,iFadeColor,iFadeColor, 1);

                glTranslatef(-iDrawOneByOneXY.iX, iDrawOneByOneXY.iY, 0);

                glRotatef(data->iGridData.iRotationAngle, 0,0,1);

                // Set vertixes and draw

                GLfixed vertices[8];

                iContainer->SetPictureVertices(data, vertices);

                glVertexPointer( 2, GL_FIXED, 0, vertices );

                glDrawArrays(GL_TRIANGLE_STRIP,0,4);

#ifdef EMPTY_IMAGE_AS_WIREFRAME

                // Draw black frame with white borders

                if (iContainer->iCurrentBindedIndex == 0)

                    {

                    glScalef(0.92, 0.92, 0.92);

                    glColor4f(0,0,0,1);

                    glDrawArrays(GL_TRIANGLE_STRIP,0,4);

                    }

#endif                

                }

#ifdef RD_FACEFRAME

            //if (i==1 && iDrawFaceFrame) DrawFaceFrame();

#endif

            //Remove rotation

            glPopMatrix();

            }

        // Move to next image position

        glTranslatef(iContainer->KOneByOneSpacing,0,0);

        }

    glPopMatrix();

    if(currentIndexTexture!=iContainer->iCurrentBindedIndex)

        {

        iContainer->iCurrentBindedIndex = currentIndexTexture;

        glBindTexture(GL_TEXTURE_2D, iContainer->iCurrentBindedIndex);

        iContainer->SetMinMagFilterLinearDo(iContainer->iMinMagFilterSetting);

        }

#ifdef SCR_DRAW_DEBUG

    iDrawUtility->Update();

    iDrawUtility->Draw(Size());

#endif

    //iContainer->iDrawUtility->DrawMenuIndicators(iContainer->Size());

#ifdef RD_ZOOMICON

    //Draw moving direction arrays when sliding in OnByOne mode

    if(!iMagGlassOn && iFadeColor!=0 || iOneByOneFlow != 0)

        iContainer->iDrawUtility->DrawMovingArrow(ETrue, EFalse, iContainer->Size());

    //Draw moving direction arrays when zoomed in

    if (!IS_NOT_IN_ZOOM_ONEBYONE && 

        (iDrawOneByOneXY.iX != iDrawOneByOneTargetXY.iX || 

         iDrawOneByOneXY.iY != iDrawOneByOneTargetXY.iY || 

         iDrawOneByOneZoom != iDrawOneByOneTargetZoom ||

         imageData->iGridData.iRotationAngle != imageData->iGridData.iTargetRotationAngle ||

         iContainer->iOnTheEdge))

        {

        /*if(!iMagGlassOn)

            {

            iContainer->iDrawUtility->DrawMovingArrow(ETrue, !IS_NOT_IN_ZOOM_ONEBYONE, iContainer->Size());

            }*/

        iContainer->iDrawUtility->DrawZoomIcon( imageData,

                                                iContainer->Size(), 

                                                -iDrawOneByOneXY.iX, 

                                                iDrawOneByOneXY.iY,

                                                iDrawOnebyOneW/iImageWidth, 

                                                iDrawOnebyOneH/iImageHeight,

                                                ETrue);

        }

#endif    

#if 0

    if(iMenuAlpha < 1)

        {

        iMenuAlpha-=0.3;

        if(iMenuAlpha < 0)

            iMenuAlpha = 0;

        }

    iContainer->iDrawUtility->DrawIcon2(iContainer->Size(), iContainer->iMenuTextureIndex, iMenuAlpha);

#endif   

    iContainer->DynamicLoadingL();

    }

TBool CDrawOneByOne::IsDrawingNeededOneByOne()

    {

    CImageData* imageData = iContainer->iIEngine->GetImageData(iContainer->GetCurrentIndex());

#if 0

    if(iMenuAlpha != 0)

        {

        return ETrue;