/*

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

#include "TextureLoader.h"

#include "DrawUtility.h"

#include "ImagicConsts.h"

const TInt  KDrawLimit = 65;

const float KInitialZoomGrid = -4.1;//zoom value for grid when application starts drawing grid

const TReal KMaxAngleLandscape = 45;//max tilt angle when moving in grid

const TReal KMaxAnglePortrait = 10;//max tilt angle when moving in grid

//const TReal KAngle2Start128Loading = 1;

const float KTargetZCoord = -1.5;

const float KZoomInMaxGrid = -3.5;//max possible zoom value 

const float KZoomOutMaxGrid = -6;//min possible zoom value

#ifdef DOUBLETAP_ZOOMGRID

const TInt  KDoubleTapZoomGrid1 = KInitialZoomGrid;

const TInt  KDoubleTapZoomGrid2 = KZoomOutMaxGrid * 7 / 10;  // 70% of max zoom out

#endif

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

    iContainer(aContainer)//,

    //iCurrentIndex(aCurrentIndex)

    {

    // No implementation required

    }

CDrawGrid::~CDrawGrid()

    {

    }

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

    {

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

    CleanupStack::PushL(self);

    self->ConstructL(aContainer,aCurrentIndex);

    return self;

    }

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

    {

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

    CleanupStack::Pop(); // self;

    return self;

    }

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

    {

    //iContainer = aContainer;

    }

TReal CDrawGrid::GetCurrentGridTilt()

    {

    return iPerspectiveCurrent;

    }

TReal CDrawGrid::GetGridZoom()

    {

    return iDrawGridZoom;

    }

TGridXY CDrawGrid::GetGridTargetXY()

    {

    return iDrawGridTargetXY;

    }

void CDrawGrid::SetGridTargetXY(TGridXY aValue)

    {

    iDrawGridTargetXY = aValue;

    }

TGridXY CDrawGrid::GetGridXY()

    {

    return iDrawGridXY;

    }

void CDrawGrid::SetGridXY(TGridXY aValue)

    {

    iDrawGridXY = aValue;

    }

void CDrawGrid::KeyPressed()

    {

    iMenuAlpha = 1;

    iKeyTimer = 0;

    iKeyTimer2 = 10;

    }

void CDrawGrid::KeyReleased()

    {

    iMenuAlpha = 0.99;

    iKeyTimer = 0;

    iKeyTimer2 = 10;

    }

void CDrawGrid::KeyEvent()

    {

    //iMenuAlpha = 1;

    }

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

// Set perspective projection

//

void CDrawGrid::SetPrespective(const TSize &aSize)

    {

    DP0_IMAGIC(_L("CDrawGrid::SetPrespective"));

    // Calculate aspect ratio

    GLfloat aspectRatio = (GLfloat)(aSize.iWidth) / (GLfloat)(aSize.iHeight);

    // Calculate prespective values

    const float near = 0.001;

    const float far = 100.0;

    const float top = 0.414*near;

    const float bottom = -top;

    const float left = aspectRatio * bottom;

    const float right = aspectRatio * top;

    // Set perspective

    glLoadIdentity();

    glFrustumf(left,right, bottom,top, near,far);

    float tmp = iContainer->GetDisplayRotAngle();

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

    iContainer->SetDisplayRotAngle(tmp);

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

    }

void CDrawGrid::UpdateImageCoordinates(const TInt aFirstIndex)

    {

    const TReal KMinY = -(CImagicContainerBrowser::KGridSizeY - 1) * CImagicContainerBrowser::KSpacingY;

    TReal y2 = KMinY;

    TReal x2 = -CImagicContainerBrowser::KSpacingX;

    CImageData* prevImageData = iContainer->iIEngine->GetImageData(aFirstIndex - 1);

    if (prevImageData)

        {

        x2 = prevImageData->iGridData.iX;

        y2 = prevImageData->iGridData.iY;

        }

    for(TInt i = aFirstIndex; i<iContainer->iIEngine->GetTotalNumOfImages(); i++)

        {

        if ((y2 -= iContainer->KSpacingY) < KMinY)

            {

            y2 = 0;

            x2 += CImagicContainerBrowser::KSpacingX;

            }

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

#ifdef GAP_BETWEEN_FOLDERS

        TGridMode gridMode = iContainer->iIEngine->GetImageList().GetGridMode();

        if (gridMode)   

            {

            // Make small gap between folders

            CImageData* prevImageData = iContainer->iIEngine->GetImageData(i - 1);            

            if (prevImageData != NULL)

                {

                TBool gap = EFalse; 

                if (gridMode == EGridModeFolder)

                    {

                    TFileName path, prevPath;

                    imageData->GetPath(path);

                    prevImageData->GetPath(prevPath);

                    gap = (path != prevPath);

                    }

                else

                    {

                    gap = (imageData->iPersonId != prevImageData->iPersonId);

                    }

                if (gap)

                    {

                    x2 += CImagicContainerBrowser::KSpacingX / 2;

                    if (y2 < 0)

                        {

                        x2 += CImagicContainerBrowser::KSpacingX;

                        y2 = 0;

                        }

                    }

                }

            }

#endif // GAP_BETWEEN_FOLDERS            

        imageData->iGridData.iX = x2;

        imageData->iGridData.iY = y2;

        }

    }

void CDrawGrid::HandleKeys()

    {

    iKeyTimer2--;

    if(iKeyTimer2 < 0)

        iKeyTimer2 = 0;

    if(iKeyTimer == 0 || iKeyTimer2 == 0)

        {

        iKeyTimer = 3;

        CKeyData keyData = iContainer->GetKeyData();

        // Calculate new index from movement keys

        iContainer->SetCurrentIndex(keyData.iY + iContainer->GetCurrentIndex());

        // Get next image in same row

        for (TInt i = 0;i < Abs(keyData.iX);i++)

            {

            TInt index = iContainer->GetCurrentIndex();

            CImageData* currentImageData = iContainer->iIEngine->GetImageData(index);

            while (currentImageData)

                {

                index += keyData.iX > 0 ? 1 : -1;

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

                if (imageData == NULL)

                    {

                    currentImageData = NULL;

                    break;

                    }

                // Next image is found

                if (Abs(imageData->iGridData.iY - currentImageData->iGridData.iY) <

                        CImagicContainerBrowser::KSpacingY / 2)

                    {

                    iContainer->SetCurrentIndex(index);

                    currentImageData = NULL;

                    break;

                    }

                }

            }

        //iContainer->SetCurrentIndex(keyData.iX * CImagicContainerBrowser::KGridSizeY + iContainer->GetCurrentIndex());

        //We have to zero key data after reading it

        keyData.iX = 0;

        keyData.iY = 0;

        }

    else

        {

        iKeyTimer--;

        }

    }

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

// Initializes Grid view

//

void CDrawGrid::InitDrawGrid()

    {

    DP0_IMAGIC(_L("CDrawGrid::InitDrawGrid"));

    iKeyTimer = 0;

    iPerspectiveCurrent = 0;//current value of perspective when moving on grid by tilting while grid

    //iPerspectiveTarget = 0;//target value of perspective

    iDrawGridTargetZoom = KInitialZoomGrid;//Set target zooming value when draving Grid

    iGridMovingSpeed = 0.05;

    iGridZoomSpeed = 0.1;

    iGridZoomStep = 0.3;

    iDrawGridZoom = KInitialZoomGrid;//Set target zooming value when draving Grid

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

    if(imageData)

        imageData->iGridData.iScale = 6.5;

    // set scale a little bigger than initial target value to show animation in opening grid

//    CImageData* imageData = iIEngine->GetImageData(iCurrentIndex, iImagicAppUi->GetUIDrawMode());

//    if (imageData) imageData->iGridData.iScale += 0.5;

    // set zooming factor a little bigger than initial target value to show animation in opening grid

//    iDrawGridZoom = iDrawGridZoom + 0.5;

    }

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

// Draws grid

//

void CDrawGrid::DrawGridL(const TSize &aSize)

    {

    DP0_IMAGIC(_L("CDrawGrid::DrawGrid"));

    SetPrespective(aSize);// Setup perspective

    // If user hasn't press anything, stay in beginning of the grid

    if(!iContainer->IsUserInputGiven())

        {

        TInt index = -1;  

        TReal maxX = CImagicContainerBrowser::KSpacingX; 

        if(iContainer->GetScreenSize().iHeight > 240)

            maxX = CImagicContainerBrowser::KSpacingX * 2;

        // Select image which closest to ideal position

        for(TInt i = 0;i < iContainer->iIEngine->GetTotalNumOfImages();i++)

            {

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

            if (imageData->iGridData.iX > maxX) 

                break;

            if (imageData->iGridData.iY > -CImagicContainerBrowser::KSpacingY * 2)

                index = i; 

            }

        if (index >= 0)

            iContainer->SetCurrentIndex(index);

        }

#ifdef MOMENTUM_MOVE

    // Move grid x and y automatically when flick

    // FindImageInScreen() has to be called here, before SetPerspective() to get 

    // OpenGL matrix before initialised in it.

    if(iContainer->iMomentumMove)

        {

        // so move automatically. Target is set in HandleGestureEnd(), when 

        // user releases touch.

        // Slowing down when it gets closer than the size of 10% of speed

        // TODO: use definition. not 0.5

        float gapX = (iContainer->iMomentumSpeedX)? (iDrawGridTargetXY.iX - iDrawGridXY.iX) / (0.5 * iContainer->iMomentumSpeedX): 0.0f;

        float gapY = (iContainer->iMomentumSpeedY)? (iDrawGridTargetXY.iY - iDrawGridXY.iY) / (0.5 * iContainer->iMomentumSpeedY): 0.0f;

        iContainer->CheckLimits(gapX, -1.0, 1.0); // max speed doesn't go beyond user's move

        iContainer->CheckLimits(gapY, -1.0, 1.0);

        float spdX = gapX * iContainer->iMomentumSpeedX; // speed/1sec. faster with bigger gap

        float spdY = gapY * iContainer->iMomentumSpeedY;

        iDrawGridXY.iX += spdX * iContainer->iTimeDiff; // movement = (open gl pixels)/sec * (elapsed time from last draw) 

        iDrawGridXY.iY += spdY * iContainer->iTimeDiff;

        DP4_IMAGIC(_L("spdX=%6.4f, gapX=%6.4f, iMomentumSpeedX=%6.4f, iTimeDiff=%6.4f"), spdX, gapX, iContainer->iMomentumSpeedX, iContainer->iTimeDiff);

        DP3_IMAGIC(_L("spdY=%6.4f, gapY=%6.4f, iMomentumSpeedY=%6.4f"), spdY, gapY, iContainer->iMomentumSpeedY);

        DP2_IMAGIC(_L("iDrawGridTargetX=%6.4f <=== iDrawGridX=%6.4f"), iDrawGridTargetXY.iX, iDrawGridXY.iX);

        DP2_IMAGIC(_L("iDrawGridTargetY=%6.4f <=== iDrawGridY=%6.4f"), iDrawGridTargetXY.iY, iDrawGridXY.iY);

        }

    // Pick up the picture in the center of the screen as current selected one.

    // Also does on dragging if not in the mode of no key event simulation on drag 

#ifdef HOLD_SELECTION_ONDRAG

    if(iContainer->iMomentumMove || iContainer->iHoldSelection)

#else

    if(iMomentumMove)

#endif

        {

        TInt id;

        FloatCoords coord;

        coord.iX = iDrawGridXY.iX;

        coord.iY = iDrawGridXY.iY;

#ifdef FLICK_ONLY_IN_X_IN_GRID

        if (iContainer->FindNearestImageInOGl(coord, id))

            {

            if (iContainer->iMomentumMove)

                {

                // Change iCurrentIndex only when x coord is changed

                TInt cX = iContainer->GetCurrentIndex() / CImagicContainerBrowser::KGridSizeY;

                TInt tX = id / CImagicContainerBrowser::KGridSizeY;

                if (cX != tX) 

                    //iCurrentIndex = id;

                    iContainer->SetCurrentIndex(id);

                }

            else

                //iCurrentIndex = id;

                iContainer->SetCurrentIndex(id);

            }

#else

        if (FindNearestImageInOGl(coord, id)) 

            //iCurrentIndex = id;

            iContainer->SetCurrentIndex(id);

#endif

        }

    if(iContainer->iMomentumMove)

        {

        // Stop momentum move when it gets close to target or exceeds 

        if ((!iContainer->iMomentumSpeedX || Abs(iDrawGridTargetXY.iX - iDrawGridXY.iX) < 0.15) && // 0.15 is just a guess.

            (!iContainer->iMomentumSpeedY || Abs(iDrawGridTargetXY.iY - iDrawGridXY.iY) < 0.15))

            {

            iContainer->iMomentumMove = EFalse;

            }

        }

#endif

#ifdef ZOOM_WHILE_ROTATING

    if(Abs(iDrawGridZoom-KZoomOutMaxGrid) < 1)

        iDrawGridTargetZoom = KInitialZoomGrid;

#endif

#ifdef ENABLE_GRID_ZOOM

    Interpolate(iDrawGridZoom, iDrawGridTargetZoom, iGridZoomSpeed);

#endif

#ifdef SCREEN_ROTATION_ON

    Interpolate(iDisplayRotation, iDisplayRotationTarget, 0.005);

#endif

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

    HandleKeys();

    //Handle Rotation keys, this is for single currently selected picture

    iContainer->HandleRotationKeys();

    //Check that current index is in grid area

    /*TInt index = iContainer->GetCurrentIndex();

    CheckIndexLimits(index);

    iContainer->SetCurrentIndex(index);*/

    // Update AppUI class about selected picture index

    if(iContainer->GetPrevIndex() != iContainer->GetCurrentIndex())

        {

        iContainer->iImagicAppUi->SetImageIndex(iContainer->GetCurrentIndex());

        iContainer->iDynamicLoadingOn = ETrue;

//#define DISPLAY_DATE

#ifdef DISPLAY_DATE

        DisplayDate();

#endif

        //Update previous Grid index..

        iContainer->SetPrevIndex(iContainer->GetCurrentIndex());        

        }

#ifdef MOMENTUM_MOVE

    if(!iContainer->iMomentumMove) 

        {

#endif

        //Calculate new target X and Y positions on Grid

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

    if (imageData)

        {

        iDrawGridTargetXY.iX = imageData->iGridData.iX;

        iDrawGridTargetXY.iY = -imageData->iGridData.iY;

        }

#ifdef HOLD_SELECTION_ONDRAG

        if (iContainer->iHoldSelection == EFalse) 

            {

#endif

            //and interpolate between current and target Y and X

            iContainer->Interpolate(iDrawGridXY.iX, iDrawGridTargetXY.iX, iGridMovingSpeed);

            iContainer->Interpolate(iDrawGridXY.iY, iDrawGridTargetXY.iY, iGridMovingSpeed);

#ifdef HOLD_SELECTION_ONDRAG

            }

#endif

#ifdef MOMENTUM_MOVE

        }

#endif

    // Zooming

    //Calculate new target zooming value for Grid

//unno temp iGridZoomSpeed = 20 * iTimeDiff;

#ifdef ENABLE_GRID_ZOOM

    iDrawGridTargetZoom += keyData.iZoomIn * iGridZoomStep;

    iDrawGridTargetZoom -= keyData.iZoomOut * iGridZoomStep;

    CheckLimits(iDrawGridTargetZoom, KZoomOutMaxGrid, KZoomInMaxGrid);

    keyData.iZoom = 0;//we have to reset key data after using it

    keyData.iZoomIn = keyData.iZoomOut = EFalse;

#endif

    //Handle Rotation keys, this is for single currently selected picture

    //iContainer->HandleRotationKeys();

    // Draw images ---------------------------------->

    //Tilt Grid(camera) into moving direction

    float perspectiveDiff = iDrawGridTargetXY.iX-iDrawGridXY.iX;

    perspectiveDiff *= 10;

    //we stop moving of the grid littele bit earlier than we are in real zero

#ifdef HOLD_SELECTION_ONDRAG

    if(iContainer->iHoldSelection == EFalse) {

#endif

    iTargetPerspective = perspectiveDiff;

#ifdef HOLD_SELECTION_ONDRAG

    }

#endif

    //Speed up tilting when getting closer to target

    if(iPerspectiveCurrent-iTargetPerspective != 0 && 

       (Abs(iTargetPerspective) < Abs(iPerspectiveCurrent)) && 

       Abs(iPerspectiveCurrent) < 20)

        {

        iContainer->Interpolate(iPerspectiveCurrent,iTargetPerspective, Abs((KMaxAngleLandscape/iPerspectiveCurrent)/40));

        }

    else

        {

        iContainer->Interpolate(iPerspectiveCurrent,iTargetPerspective, 0.04);

        }

#ifdef _ACCELEROMETER_SUPPORTED_

//#ifndef _S60_5x_ACCELEROMETER_

    if(iContainer->iDeviceOrientation == EOrientationDisplayLeftUp)//Landscape

/*#else if _S60_5x_ACCELEROMETER_

    if(iContainer->iDeviceOrientation == (TImagicDeviceOrientation)TSensrvOrientationData::EOrientationDisplayRightUp)///this is wrong

#endif*/

#else

    if(ETrue/*iDeviceOrientation*/)//if no accelerometer, use always landscape

#endif

        iContainer->CheckLimits(iPerspectiveCurrent, -KMaxAngleLandscape, KMaxAngleLandscape);  

    else

        iContainer->CheckLimits(iPerspectiveCurrent, -KMaxAnglePortrait, KMaxAnglePortrait);

    glRotatef(iPerspectiveCurrent, 0,1,0);//make perspective when moving on grid

    //Go to grid position ----------->

    //Center picture grid and set limit of pictures to be drawn

    float centerOffset=2.9;//bigger value -> less movement in Y-axis

#ifdef MOMENTUM_MOVE

    glTranslatef(-iDrawGridXY.iX-iDrawGridZoom*iPerspectiveCurrent/KMaxAngleLandscape,

            CImagicContainerBrowser::KSpacingY+(iDrawGridXY.iY-CImagicContainerBrowser::KSpacingY)/centerOffset, iDrawGridZoom);

#else