/*

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

#include "debug.h"

const KTNSize = 10;

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

// Class constants

// Mesh data

// Triangle count

const int CDrawUtility::iTriCount = 4;

// Vertices

const GLfixed CDrawUtility::iVertices[4*3]=

	{

	// Tetrahedron coordinates

	10*(1<<16),		10*(1<<16),		10*(1<<16),

	-10*(1<<16),	-10*(1<<16),	10*(1<<16),

	-10*(1<<16),	10*(1<<16),		-10*(1<<16),

	10*(1<<16),		-10*(1<<16),	-10*(1<<16),

	};

// Normals

const GLfixed CDrawUtility::iNormals[4*3]=

	{

	// Tetrahedron normals

	/*

	Normal is a vector with unit lenght (length=1)

	Unit lenght vector = vector/lenght

	Calculate normals from corners, makes gouraud shading

	Vector: (1,1,1)

	Lenght = SQRT( 1*1 + 1*1 + 1*1 ) = SQRT(3) = 1.732050808

	1/Lenght = 0.577350269

	In fixed point: 0.577350269*(1<<16) = 37837

	*/

	37837,	37837,	37837,

	-37837,	-37837,	37837,

	-37837,	37837,	-37837,

	37837,	-37837,	-37837,

	};

// Indexes define which vertices make a triangle

// These are just indexes to iVertices table

const GLushort CDrawUtility::iIndices[4*3]=

	{

	0,2,3,

	0,1,3,

	0,1,2,

	2,1,3,

	};

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

// NewL

//

//CDrawableInterface* CDrawUtility::NewL(void)

CDrawUtility* CDrawUtility::NewL(CImagicContainerBrowser* aContainer)

	{

	// Create object

	CDrawUtility* self = new(ELeave) CDrawUtility();

	// Call 2nd stage constructor

	CleanupStack::PushL(self);

	self->ConstructL(aContainer);

	CleanupStack::Pop(self);

	return self;

	}

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

// Constructor

//

CDrawUtility::CDrawUtility() :

		//CDrawableInterface(),

		iAngleX(0),

		iAngleY(0),

		iAngleZ(0)

	{

	// Nothing here

	}

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

// Second stage constructor

//

void CDrawUtility::ConstructL(CImagicContainerBrowser* aContainer)

	{

	iContainer = aContainer;

	iRotation = 0;

	iRotationTarget = 0;

	float ambient[4]={0.3,0.3,0.3, 1};

	float diffuse[4]={1, 1, 1, 1};

    glLightfv(GL_LIGHT0,GL_AMBIENT, ambient);

    glLightfv(GL_LIGHT0,GL_DIFFUSE, diffuse);

	}

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

// Destructor

//

CDrawUtility::~CDrawUtility()

	{

	// Nothing here

	}

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

// Makes sure that angle is on valid range

//

void CDrawUtility::LimitAngle(TInt &Angle)

	{

	while (Angle<0)

		Angle+=360;

	while (Angle>360)

		Angle-=360;

	}

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

// Update animation

// Returns true if screen should be redrawn

//

TBool CDrawUtility::Update(void)

	{

	// Rotate

	iAngleX+=4;

	iAngleY+=2;

	iAngleZ-=2;

	// Check limist

	LimitAngle(iAngleX);

	LimitAngle(iAngleY);

	LimitAngle(iAngleZ);

	// Since this is loading animation, this doesn't want screen to be updated

	return EFalse;

	}

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

// Draws Zoom image thumbnail

//

void CDrawUtility::DrawZoomIcon(    const CImageData* aImageData,

                                    const TSize aScreenSize, 

                                    float aDrawOneByOneX, 

                                    float aDrawOneByOneY,

                                    TReal aDrawOnebyOneW, 

                                    TReal aDrawOnebyOneH,

                                    TBool aShowLocationRect)

    {

    iScrAspectratio = (TReal)aScreenSize.iWidth/(TReal)aScreenSize.iHeight;

    if(aImageData->iGridData.iGlLQ128TextIndex != 0)

        {

        iDrawOneByOneX = aDrawOneByOneX; 

        iDrawOneByOneY = aDrawOneByOneY;

        iDrawOnebyOneW = aDrawOnebyOneW; 

        iDrawOnebyOneH = aDrawOnebyOneH;

        iAspectRatio = aImageData->GetAspectRatio();

        iScrSize = aScreenSize;

        //Define thumbnail size dependinf on screen orientation

        if(iAspectRatio > 1)

            {

            iThumbSize.iWidth=(iScrSize.iWidth/KTNSize);

            iThumbSize.iHeight=iThumbSize.iWidth/iAspectRatio;

            iZoomRectSize.iWidth = iScrSize.iWidth/KTNSize;

            iZoomRectSize.iHeight = iZoomRectSize.iWidth/iScrAspectratio;

            }

        else

            {

            iThumbSize.iWidth=(iScrSize.iHeight/KTNSize);

            iThumbSize.iHeight=iThumbSize.iWidth/iAspectRatio;

            iZoomRectSize.iHeight = iScrSize.iHeight/KTNSize;

            iZoomRectSize.iWidth = iZoomRectSize.iHeight*iScrAspectratio;

            }

        GLfixed vertices[8];

        SetPictureVertices(vertices, iAspectRatio);

        glColor4f(1,1,1, 1);

        // Set OpenGL state

        glDepthMask(GL_FALSE);

        glDisable(GL_DEPTH_TEST);

        glEnable(GL_TEXTURE_2D);

        glVertexPointer( 2, GL_FIXED, 0, vertices );

        glPushMatrix();

        // Set ortho to match screen size

        glLoadIdentity();

        glOrthof(0,aScreenSize.iWidth, aScreenSize.iHeight,0, -50,50);

        //Move to top right corner and leave some space around "frame"

        if(iContainer->GetScreenOrientation())

            {

            iRotationTarget = 0 - (TReal)aImageData->GetOrientation();

            if(iAspectRatio > 1 && iRotationTarget == 0)

                glTranslatef(iThumbSize.iWidth+4, iScrSize.iHeight-iThumbSize.iHeight-4, 1);

            else if(iAspectRatio < 1 && iRotationTarget == 0)

                glTranslatef((iThumbSize.iWidth)*iAspectRatio+4, iScrSize.iHeight-iThumbSize.iWidth-4, 1);

            else// if(iAspectRatio < 1 && iRotationTarget == 0)

                glTranslatef((iThumbSize.iHeight)+4, iScrSize.iHeight-iThumbSize.iWidth-4, 1);

            }

        else

            {

            iRotationTarget = -90 - (TReal)aImageData->GetOrientation();

            if(iAspectRatio > 1 && iRotationTarget == -90)

                glTranslatef(iScrSize.iWidth-iThumbSize.iHeight-4, iScrSize.iHeight-iThumbSize.iWidth-4, 1);

            else if(iAspectRatio < 1 && iRotationTarget == -90)

                glTranslatef(iScrSize.iWidth-(iThumbSize.iHeight*iAspectRatio)-4, iScrSize.iHeight-(iThumbSize.iWidth*iAspectRatio)-4, 1);

            else// if(iAspectRatio < 1 && iRotationTarget == -90)

                glTranslatef(iScrSize.iWidth-(iThumbSize.iHeight*iAspectRatio)-4, iScrSize.iHeight-(iThumbSize.iHeight)-4, 1);

            }

        iContainer->Interpolate(iRotation, iRotationTarget, 0.60);

        glRotatef(iRotation, 0,0,1);

        DrawFrame(0);

        glBindTexture(GL_TEXTURE_2D, aImageData->iGridData.iGlLQ128TextIndex);

        glDrawArrays(GL_TRIANGLE_STRIP,0,4);

        // Restore OpenGL state

        glDepthMask(GL_TRUE);

        glEnable(GL_DEPTH_TEST);

        glEnable(GL_TEXTURE_2D);

        //glDisable(GL_BLEND);

        if(aShowLocationRect)

            DrawZoomFrame(iRotationTarget);

        glDisableClientState(GL_VERTEX_ARRAY);

        glDisableClientState(GL_TEXTURE_COORD_ARRAY);

        glPopMatrix();

        }

    }

//Shows rectangle for zoomed are

void CDrawUtility::DrawZoomFrame(float aRotationTarget)

    {

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

    DP1_IMAGIC(_L("CImagicContainerBrowser::DrawZoomFrame - aRotationTarget: %f"),aRotationTarget);

    GLfixed vertices[8];

    glPushMatrix();

    glDisable(GL_TEXTURE_2D);

    glTranslatef(0, 0, 0.01f);

    glColor4f(0,0.7,0,1);

    glLineWidth(2.0f);

    glVertexPointer(2, GL_FIXED, 0, vertices);

	TReal xPos = iDrawOneByOneX*(TReal)iThumbSize.iWidth*2;

	TReal yPos = iDrawOneByOneY*(TReal)iThumbSize.iHeight*2*iAspectRatio;

	//float x,y;

	TInt x,y;

	TInt rotationTarget = aRotationTarget;

	rotationTarget%=360;

	if(rotationTarget == 0)

	    {

	    glTranslatef(-xPos, yPos, 0);

	    if(iAspectRatio > 1)

	        {

	        x=iDrawOnebyOneW*iZoomRectSize.iWidth * (1<<16);

	        y=iDrawOnebyOneW*iZoomRectSize.iHeight * (1<<16);

	        }

	    else

	        {

	        x=iDrawOnebyOneH*iZoomRectSize.iWidth * (1<<16);

            y=iDrawOnebyOneH*iZoomRectSize.iHeight * (1<<16);

	        }

	    }

	else if(rotationTarget == -90)

        {

        glTranslatef(-yPos, -xPos, 0);

        if(iAspectRatio > 1)

            {

            y=iDrawOnebyOneH*iScrAspectratio*iZoomRectSize.iWidth * (1<<16);

            x=iDrawOnebyOneH*iScrAspectratio*iZoomRectSize.iHeight * (1<<16);

            }

        else

            {

            y=iDrawOnebyOneH*iZoomRectSize.iWidth * (1<<16);

            x=iDrawOnebyOneH*iZoomRectSize.iHeight * (1<<16);

            }

        }

	else if(rotationTarget == -180)

        {

        glTranslatef(xPos, -yPos, 0);

        if(iAspectRatio > 1)

            {

            x=iDrawOnebyOneW*iZoomRectSize.iWidth * (1<<16);

            y=iDrawOnebyOneW*iZoomRectSize.iHeight * (1<<16);

            }

        else

            {

            x=iDrawOnebyOneH*iZoomRectSize.iWidth * (1<<16);

            y=iDrawOnebyOneH*iZoomRectSize.iHeight * (1<<16);

            }

        }

	else if(rotationTarget == -270)

        {

        glTranslatef(yPos, xPos, 0);

        if(iAspectRatio > 1)

            {

            y=iDrawOnebyOneH*iScrAspectratio*iZoomRectSize.iWidth * (1<<16);

            x=iDrawOnebyOneH*iScrAspectratio*iZoomRectSize.iHeight * (1<<16);

            }

        else

            {

            y=iDrawOnebyOneH*iZoomRectSize.iWidth * (1<<16);

            x=iDrawOnebyOneH*iZoomRectSize.iHeight * (1<<16);

            }

        }

	TInt tnSizeFixedH = iThumbSize.iHeight*(1<<16);

	TInt tnSizeFixedW = iThumbSize.iWidth*(1<<16);

	if(y > tnSizeFixedH)

	    y=tnSizeFixedH;

	if(x > tnSizeFixedW)

        x=tnSizeFixedW;

	vertices[0*2+0] = -x;	vertices[0*2+1] = -y;

	vertices[1*2+0] =  x;	vertices[1*2+1] = -y;

	vertices[2*2+0] =  x;	vertices[2*2+1] =  y;

	vertices[3*2+0] = -x;	vertices[3*2+1] =  y;

    glDrawArrays(GL_LINE_LOOP,0,4);

    glColor4f(1,1,1,1);

    glEnable(GL_TEXTURE_2D);

    glPopMatrix();

    DP0_IMAGIC(_L("CImagicContainerBrowser::DrawZoomFrame--"));

    }

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

// Draws background frame

//

void CDrawUtility::DrawFrame(TInt aIndex)

    {

    // Draw frame around selected image

    glPushMatrix();

    glDisable(GL_TEXTURE_2D);

    //Frame size

    float scale=1.09;

    glColor4f(1,1,1, 1);

    glTranslatef(0,0,-0.03);

    glScalef(scale,scale,scale);

    glDrawArrays(GL_TRIANGLE_STRIP,0,4);

    //glDisable(GL_BLEND);

    glEnable(GL_TEXTURE_2D);

    glPopMatrix();

    }

void CDrawUtility::SetPictureVertices(GLfixed* aVertices, TReal aAspectRatio)

    {

    //DP0_IMAGIC(_L("CImagicContainerBrowser::SetPictureVertices"));

    GLfixed vx = (iThumbSize.iWidth)*(1<<16);

    GLfixed vy = (iThumbSize.iWidth)*(1<<16);

    if(aAspectRatio > 1)

        {

        vy = ((iThumbSize.iWidth)/aAspectRatio)*(1<<16);

        }

    else

        {

        vx = ((iThumbSize.iWidth)*aAspectRatio)*(1<<16);

        }

    aVertices[0*2+0] = -vx;

    aVertices[0*2+1] = vy;

    aVertices[1*2+0] = vx;

    aVertices[1*2+1] = vy;

    aVertices[2*2+0] = -vx;

    aVertices[2*2+1] = -vy;

    aVertices[3*2+0] = vx;

    aVertices[3*2+1] = -vy;

    }

#if 1

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

// Draw moving arrow

//

void CDrawUtility::DrawMovingArrow(TBool aPrevArrow, TBool aUpDownArrow, const TSize& aScreenSize)

    {

    //Define shape of direction array

    const GLfixed vertices[4*2] = 

		{

		0*1<<16,  0*1<<16,

		10*1<<16, 7*1<<16,

		7*1<<16,  0*1<<16,

		10*1<<16,-7*1<<16,

		};

    //Define colors of direction array

    const GLubyte colors[4*4] = 

		{

		//61,174,227, 128,

		/*255,255,255, 255,

		81,194,247, 255,

		61,174,227, 255,

		41,154,207, 255,*/

        255,255,255, 255,

        128,128,128, 255,

        50,50,50, 255,

        128,128,128, 255,

		};

    //And order of drawing

	const GLushort indices[2*3]=

		{

		0,1,2,

		2,3,0,

		};

	TReal scale = 1;

	if(aScreenSize.iHeight > 320 || aScreenSize.iWidth > 320)

	    {

	    scale = 1.5;

	    }

    // Set OpenGL state

	// Shade model

    glShadeModel(GL_SMOOTH);

    glDepthMask(GL_FALSE);

    glDisable(GL_DEPTH_TEST);

    glDisable(GL_TEXTURE_2D);

    glDisableClientState(GL_TEXTURE_COORD_ARRAY);

    glEnableClientState(GL_COLOR_ARRAY);

    glPushMatrix();

#ifdef ENABLE_ALPHA

	// Setup alpha

	glEnable(GL_ALPHA_TEST);

	glEnable(GL_BLEND);

	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

#endif	

    // Set ortho to match screen size

    glLoadIdentity();

    glOrthof(0,aScreenSize.iWidth, aScreenSize.iHeight,0, -100,100);

    glPushMatrix();

    // Move to arrow position

	int ArrowDistance=5;

	if(aPrevArrow)

		{

		glTranslatef(ArrowDistance,aScreenSize.iHeight/2,0);

        glVertexPointer(2,GL_FIXED,0, vertices);

        glColorPointer(4,GL_UNSIGNED_BYTE,0, colors);

        glScalef(scale,scale,scale);

        glDrawElements(GL_TRIANGLES, 2*3, GL_UNSIGNED_SHORT, indices);

        glScalef(1/scale,1/scale,1/scale);

		glTranslatef(aScreenSize.iWidth-2*ArrowDistance,0/*aScreenSize.iHeight/2*/,0);

		// Flip arrow around so it points to right

	    glRotatef(180,0,0,1);

		// Also flip it on X

		//glRotatef(180,1,0,0);

		glVertexPointer(2,GL_FIXED,0, vertices);

        glColorPointer(4,GL_UNSIGNED_BYTE,0, colors);

        glScalef(scale,scale,scale);

        glDrawElements(GL_TRIANGLES, 2*3, GL_UNSIGNED_SHORT, indices);

        glScalef(1/scale,1/scale,1/scale);

        glPopMatrix();

		glPushMatrix();

	    }

    if(aUpDownArrow)

        {

        glTranslatef(aScreenSize.iWidth/2, ArrowDistance,0);

        //glTranslatef(aScreenSize.iWidth/2,(aScreenSize.iHeight)-ArrowDistance,0);

        // Flip arrow around so it points to right

        glRotatef(90,0,0,1);

        // Also flip it on X

        //glRotatef(180,1,0,0);

        // Draw arrow

        glVertexPointer(2,GL_FIXED,0, vertices);

        glColorPointer(4,GL_UNSIGNED_BYTE,0, colors);

        glScalef(scale,scale,scale);

        glDrawElements(GL_TRIANGLES, 2*3, GL_UNSIGNED_SHORT, indices);

        glScalef(1/scale,1/scale,1/scale);

        glTranslatef(aScreenSize.iHeight-ArrowDistance*2,0,0);

		glRotatef(180,0,0,1);

        // Draw arrow

        glVertexPointer(2,GL_FIXED,0, vertices);

        glColorPointer(4,GL_UNSIGNED_BYTE,0, colors);

        glScalef(scale,scale,scale);

        glDrawElements(GL_TRIANGLES, 2*3, GL_UNSIGNED_SHORT, indices);

        glScalef(1,1,1);

        }