/*

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

#include "TextureLoader.h"

#include "DrawUtility.h"

#include "ImagicConsts.h"

#define IS_ALMOST_ZERO (0.001)

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

    iContainer(aContainer)//,

    //iCurrentIndex(aCurrentIndex)

    {

    // No implementation required

    }

CDrawFaceBrowsing::~CDrawFaceBrowsing()

    {

    iCoordinates.Close();

    iFloatCoordinates.Close();

    }

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

    {

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

    CleanupStack::PushL(self);

    self->ConstructL(aContainer,aCurrentIndex);

    return self;

    }

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

    {

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

    CleanupStack::Pop(); // self;

    return self;

    }

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

    {

    //iContainer = aContainer;

    }

void CDrawFaceBrowsing::KeyPressed()

    {

    iMenuAlpha = 1;

    }

void CDrawFaceBrowsing::KeyReleased()

    {

    iMenuAlpha = 0.99;

    }

void CDrawFaceBrowsing::KeyEvent()

    {

    //iMenuAlpha = 1;

    }

void CDrawFaceBrowsing::GetFBZoomAndLocation(TReal& aDrawZoom, TReal& aInPictureX, TReal& aInPictureY)

    {

    aDrawZoom = iDrawZoom;

    aInPictureX = iInPictureX;

    aInPictureY = iInPictureY;

    }

void CDrawFaceBrowsing::InitFaceBrowsing()

    {

    //iFBMovingSpeed = 1.4*iContainer->iTimeDiff;

    iFBMovingSpeed = 0.1;

    iFBRectCounter = 0;

    //iContainer->iDrawOneByOneTargetZoom=1;

    iDrawZoom=1;

    iDrawFBTargetZoom=1;

    iFBZoomingSpeed = 1.2*iContainer->iTimeDiff;

    iDrawX=0;

    iDrawY=0;

    iDrawTargetX=0;

    iDrawTargetY=0;

    //iInPictureX, iInPictureY

    }

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

// Draws FaceBrowser view

//

void CDrawFaceBrowsing::DrawFaceBrowsing(const TSize &aSize)

    {

    DP0_IMAGIC(_L("CDrawFaceBrowsing::DrawFaceBrowsing"));

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

#ifdef SUPERZOOM

    if(imageData->iGridData.iGlSuperHQTextIndex == 0)

        {

        TRAPD(err, iContainer->iTextureLoader->LoadL(imageData, EFullSize));

        }

#endif

    //Calculate screen size

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

    if(imageData->iGridData.iRotationAngle != imageData->iGridData.iTargetRotationAngle)

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

    //Interpolate current screen size into the new one

    iContainer->Interpolate(iDrawWidth, iImageWidth, 0.75);

    iContainer->Interpolate(iDrawHeight, iImageHeight, 0.75);

    //Set orthigonal projection

    glLoadIdentity();

    glOrthof(-iDrawWidth,iDrawWidth, -iDrawHeight, iDrawHeight, -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 coordinates----------------------->

    if(iFaceNro < 0)

        iFaceNro = iCoordinates.Count()-1;

    if(iFaceNro >= iCoordinates.Count())

        iFaceNro = 0;

    // Interpolate to new zoom value

    if( iContainer->iView->GetFaceBrowsingMode() != EFaceBrowsingShowRect )

        iContainer->Interpolate(iDrawZoom, iDrawFBTargetZoom, iFBZoomingSpeed);

    //Convert coordinates from corner to center of screen

    if(iCoordinates.Count() >= 1)

        {

        //Convert integer coords to OpenGL float coords and fill array

        for(TInt i=0; iFloatCoordinates.Count() < iCoordinates.Count();i++)

            {

            iFloatCoordinates.Append(ConvertCoordsFromAlgo2OGl(iCoordIndex));

            iCoordIndex++;

            }

        iDrawTargetX = iFloatCoordinates[iFaceNro].iX;

        iDrawTargetY = iFloatCoordinates[iFaceNro].iY;

        //Calculate face width and use that for zooming in factor

        float faceWidth = (iCoordinates[iFaceNro].iBr.iX - iCoordinates[iFaceNro].iTl.iX);

        float zoomFactor = faceWidth/20;

        if(iContainer->GetScreenOrientation())

            iDrawFBTargetZoom = 4.6;

        else

            iDrawFBTargetZoom = 5.4;

        iDrawFBTargetZoom /= zoomFactor;

        if(iDrawFBTargetZoom <=1.6)

            iDrawFBTargetZoom = 1.6;

        }

    /*iContainer->iTouchMoveData.iX=0;

    iContainer->iTouchMoveData.iY=0;*///mika. to test doe this make anything at all????

    // Calculate picture size

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

    iImageWidth*=iDrawFBTargetZoom;

    iImageHeight*=iDrawFBTargetZoom;

    //Calculate location/coordinates in screen

    iInPictureX = iDrawTargetX * iDrawFBTargetZoom;

    iInPictureY = iDrawTargetY * iDrawFBTargetZoom;

    iDrawTargetX = iInPictureX / iDrawFBTargetZoom;

    iDrawTargetY = iInPictureY / iDrawFBTargetZoom;

    if(!iContainer->GetScreenOrientation())

        {

        float temp = iDrawTargetX;

        iDrawTargetX = iDrawTargetY;

        iDrawTargetY = -temp ;

        }

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

    if( iContainer->iView->GetFaceBrowsingMode() != EFaceBrowsingShowRect )

        {

        TInt imageRotation = 0 - (TReal)imageData->GetOrientation();

        imageRotation%=360;

        if(imageRotation == 0)

            {

            iContainer->Interpolate(iDrawX,iDrawTargetX, iFBMovingSpeed);

            iContainer->Interpolate(iDrawY,iDrawTargetY, iFBMovingSpeed);

            }

        else if(imageRotation == -90)

            {

            iContainer->Interpolate(iDrawX,iDrawTargetY, iFBMovingSpeed);

            iContainer->Interpolate(iDrawY,-iDrawTargetX, iFBMovingSpeed);

            }

        else if(imageRotation == -180)

            {

            iContainer->Interpolate(iDrawX,-iDrawTargetX, iFBMovingSpeed);

            iContainer->Interpolate(iDrawY,-iDrawTargetY, iFBMovingSpeed);

            }

        else if(imageRotation == -270)

            {

            iContainer->Interpolate(iDrawX,-iDrawTargetY, iFBMovingSpeed);

            iContainer->Interpolate(iDrawY,iDrawTargetX, iFBMovingSpeed);

            }

        }

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

    glBindTexture( GL_TEXTURE_2D, iContainer->iCurrentBindedIndex);

    iContainer->SetMinMagFilterLinearDo(iContainer->iMinMagFilterSetting);

    // Calculate picture vertices

    GLfixed vertices[8];

    iContainer->SetPictureVertices(imageData, vertices);

    glVertexPointer( 2, GL_FIXED, 0, vertices );

    glColor4f(1,1,1, 1);

    glPushMatrix();

    glScalef(iDrawZoom, iDrawZoom, iDrawZoom);

    glTranslatef(-iDrawX, iDrawY, 0);

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

    glDrawArrays(GL_TRIANGLE_STRIP,0,4);

#ifdef RD_FACEFRAME

    if( iContainer->iView->GetFaceBrowsingMode() == EFaceBrowsingShowRect )

        DrawFaceFrame(-1);

    if(ShowUtilities())

        DrawFaceFrame(iFaceNro);

    //Draw face rects for ~ 0.5s time

    if(iFBRectCounter > 6)

        iContainer->iView->SetFaceBrowsingMode(EFaceBrowsing);

    else

        iFBRectCounter++;

#endif

    glPopMatrix();

#ifdef RD_ZOOMICON

    if(ShowUtilities())

        {

        //Draw moving direction arrays

        if(iFloatCoordinates.Count() >1)

            {

            TInt imageRotation = 0 - (TReal)imageData->GetOrientation();

            if(iContainer->GetScreenOrientation())

                {

                if(imageRotation == 0 || imageRotation == -180)

                    {

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

                    }

                else if(imageRotation == -90 || imageRotation == -270)

                    {

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

                    }    

                }

            if(!iContainer->GetScreenOrientation())

                {

                if(imageRotation == 0 || imageRotation == -180)

                    {

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

                    }

                else if(imageRotation == -90 || imageRotation == -270)

                    {

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

                    }    

                }

            //iContainer->iDrawUtility->DrawMovingArrow(iContainer->GetScreenOrientation(), !iContainer->GetScreenOrientation(), iContainer->Size());

            }

        iContainer->iDrawUtility->DrawZoomIcon( imageData,

                                                iContainer->Size(), 

                                                -iDrawX, 

                                                iDrawY,

                                                iDrawWidth/iImageWidth, 

                                                iDrawHeight/iImageHeight,

                                                iContainer->iView->GetFaceBrowsingMode()==EFaceBrowsing);

        }

#endif

#if 0

    if(iMenuAlpha < 1)

        {

        iMenuAlpha-=0.2;

        if(iMenuAlpha < 0)

            iMenuAlpha = 0;

        }

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

#endif   

    }

TBool CDrawFaceBrowsing::ShowUtilities()

    {

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

    TInt imageRotation = 0 - (TReal)imageData->GetOrientation();

    if(imageRotation == -90 || imageRotation == -270)

        {

        if(Abs(iDrawX) != Abs(iDrawTargetY) || 

           Abs(iDrawY) != Abs(iDrawTargetX) || 

           iDrawZoom != iDrawFBTargetZoom ||

           Abs(imageData->iGridData.iRotationAngle) != Abs(imageData->iGridData.iTargetRotationAngle) )

            {

            return ETrue;

            }

        else

            {

            return EFalse;

            }

        }

    else

        {

        if(Abs(iDrawX) != Abs(iDrawTargetX) || 

           Abs(iDrawY) != Abs(iDrawTargetY) || 

           iDrawZoom != iDrawFBTargetZoom ||

           Abs(imageData->iGridData.iRotationAngle) != Abs(imageData->iGridData.iTargetRotationAngle) )

            {

            return ETrue;

            }

        else

            {

            return EFalse;

            }

        }

    }

void CDrawFaceBrowsing::DrawFaceFrame(TInt aFace2bDrawn)

    {

    DP0_IMAGIC(_L("CDrawFaceBrowsing::DrawFaceFrame++"));

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

    RArray<TRect> facecoords;

    facecoords.Reset();

    //if(imageData->IsImageReady(ESize512x512))

        {

        for(TInt i=0; i< iCoordinates.Count();i++)

            facecoords.Append(iCoordinates[i]);    

        GLfixed vertices[8];

        glPushMatrix();

        glDisable(GL_TEXTURE_2D);

        glTranslatef(0, 0, 0.01f);

        glColor4f(0,0.7,0,1);

        glLineWidth(3.0f);

        glVertexPointer(2, GL_FIXED, 0, vertices);

        for(TInt i=0; i< facecoords.Count();i++)

            {

            GLfixed vx = (1<<15) * Abs(facecoords[i].iBr.iX + facecoords[i].iTl.iX);

            GLfixed vy = (1<<15) * Abs(facecoords[i].iBr.iY + facecoords[i].iTl.iY);

            GLfixed fW = (1<<16) * Abs(facecoords[i].iBr.iX - facecoords[i].iTl.iX);

            GLfixed fH = (1<<16) * Abs(facecoords[i].iBr.iY - facecoords[i].iTl.iY);

            DP5_IMAGIC(_L("CDrawFaceBrowsing::DrawFaceFrame face:%d (%d,%d), W/H=%d,%d"), i, vx, vy, fW, fH);

            vx /= 320; // Coords are given in 320x320 coords

            vy /= 320; // convert to OpenGL 1.0x1.0 coords

            fW /= 320;

            fH /= 320;

            float ar = imageData->GetAspectRatio();

            if(ar > 1)

                {

                vx -= (1<<15);

                vy -= (0.5/ar)*(1<<16);

                }

            else

                {

                vx -= (0.5*ar)*(1<<16);

                vy -= (1<<15);

                }

            GLfixed x1 =  vx-fW/2, x2 =  vx+fW/2;

            GLfixed y1 = -vy-fH/2, y2 = -vy+fH/2; // -vy since y-coord in OpenGL is so

            DP5_IMAGIC(_L("CDrawFaceBrowsing::DrawFaceFrame face:%d (%d,%d), W/H=%d,%d"), i, vx, vy, fW, fH);

            DP4_IMAGIC(_L("CDrawFaceBrowsing::DrawFaceFrame xy12 (%d,%d), (%d,%d)"), x1, y1, x2, y2);

            vertices[0*2+0] = x1;    vertices[0*2+1] = y1;

            vertices[1*2+0] = x2;    vertices[1*2+1] = y1;

            vertices[2*2+0] = x2;    vertices[2*2+1] = y2;

            vertices[3*2+0] = x1;    vertices[3*2+1] = y2;

            if(i == aFace2bDrawn || aFace2bDrawn == -1)

                glDrawArrays(GL_LINE_LOOP,0,4);

            }

        glColor4f(1,1,1,1);

        glEnable(GL_TEXTURE_2D);

        glPopMatrix();

        }

    DP0_IMAGIC(_L("CDrawFaceBrowsing::DrawFaceFrame--"));

    }

TBool CDrawFaceBrowsing::IsDrawingNeededFaceBrowsing()

    {

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

    if(Abs(iContainer->GetDisplayRotAngle() - iContainer->GetDisplayRotTargetAngle()) > 1)

        {

        DP0_IMAGIC(_L("CDrawFaceBrowsing::IsDrawingNeededOneByOne - 6"));

        iContainer->SetMinMagFilterLinear(EFalse);

        return ETrue;

        }

    else if(iContainer->GetDisplayRotAngle() != iContainer->GetDisplayRotTargetAngle())

        {

        DP0_IMAGIC(_L("CDrawFaceBrowsing::IsDrawingNeededOneByOne - 6.1"));

        //iContainer->iDisplayRotation = iContainer->iDisplayRotationTarget;

        iContainer->SetDisplayRotAngle(iContainer->GetDisplayRotTargetAngle());

        //iContainer->iDrawOneMoreTime = ETrue;

        iContainer->SetMinMagFilterLinear(ETrue);

        return ETrue;

        }

    if(Abs(imageData->iGridData.iRotationAngle - imageData->iGridData.iTargetRotationAngle) > 1)

        {

        DP0_IMAGIC(_L("CDrawFaceBrowsing::IsDrawingNeededOneByOne - 7"));

        iContainer->SetMinMagFilterLinear(EFalse);

        return ETrue;

        }

    else if(imageData->iGridData.iRotationAngle != imageData->iGridData.iTargetRotationAngle)

        {

        DP0_IMAGIC(_L("CDrawFaceBrowsing::IsDrawingNeededOneByOne - 7.1"));

        imageData->iGridData.iRotationAngle = imageData->iGridData.iTargetRotationAngle;

        iContainer->SetMinMagFilterLinear(ETrue);

        //iContainer->iDrawOneMoreTime = ETrue;

        return ETrue;

        }

    if(Abs(iDrawZoom - iDrawFBTargetZoom) > 0.01)

        {

        DP0_IMAGIC(_L("CDrawFaceBrowsing::IsDrawingNeededOneByOne - 10"));

        iContainer->SetMinMagFilterLinear(EFalse);

        return ETrue;

        }

    else if(iDrawZoom != iDrawFBTargetZoom)

        {

        DP0_IMAGIC(_L("CDrawFaceBrowsing::IsDrawingNeededOneByOne - 10.1"));

        iDrawZoom = iDrawFBTargetZoom;

        //iContainer->iDrawOneMoreTime = ETrue;

        iContainer->SetMinMagFilterLinear(ETrue);

        return ETrue;

        }

    TInt imageRotation = 0 - (TReal)imageData->GetOrientation();

    if(imageRotation == -90 || imageRotation == -270)

        {

        if(Abs(Abs(iDrawX)-Abs(iDrawTargetY)) > 0.001)

            {

            DP0_IMAGIC(_L("CDrawFaceBrowsing::IsDrawingNeededOneByOne - 11"));

            iContainer->SetMinMagFilterLinear(EFalse);

            return ETrue;

            }

        else if(Abs(iDrawX) != Abs(iDrawTargetY))

            {

            DP0_IMAGIC(_L("CDrawFaceBrowsing::IsDrawingNeededOneByOne - 11.1"));

            if(iDrawX < 0)

                iDrawX = 0-Abs(iDrawTargetY);

            else

                iDrawX = Abs(iDrawTargetY);

            //iContainer->iDrawOneMoreTime = ETrue;

            iContainer->SetMinMagFilterLinear(ETrue);

            return ETrue;

            }

        if(Abs(Abs(iDrawY)-Abs(iDrawTargetX)) > 0.001)

            {

            DP0_IMAGIC(_L("CDrawFaceBrowsing::IsDrawingNeededOneByOne - 12"));

            iContainer->SetMinMagFilterLinear(EFalse);

            return ETrue;

            }

        else if(Abs(iDrawY) != Abs(iDrawTargetX))

            {

            DP0_IMAGIC(_L("CDrawFaceBrowsing::IsDrawingNeededOneByOne - 12.1"));

            if(iDrawY < 0)

                iDrawY = 0-Abs(iDrawTargetX);

            else

                iDrawY = Abs(iDrawTargetX);

            //iContainer->iDrawOneMoreTime = ETrue;

            iContainer->SetMinMagFilterLinear(ETrue);

            return ETrue;

            }

        }

    else

        {

        if(Abs(iDrawX-iDrawTargetX) > 0.001)

            {

            DP0_IMAGIC(_L("CDrawFaceBrowsing::IsDrawingNeededOneByOne - 11"));

            iContainer->SetMinMagFilterLinear(EFalse);

            return ETrue;

            }