--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/AppSrc/DrawUtility.cpp Fri Oct 15 10:18:29 2010 +0900
@@ -0,0 +1,831 @@
+/*
+* 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);
+ }
+
+ glPopMatrix();
+#ifdef ENABLE_ALPHA
+ // Remove alpha
+ glDisable(GL_BLEND);
+ glDisable(GL_ALPHA_TEST);
+#endif
+ // Restore OpenGL state
+ glDepthMask(GL_TRUE);
+ glEnable(GL_DEPTH_TEST);
+ glEnable(GL_TEXTURE_2D);
+ glShadeModel(GL_FLAT);
+ glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+ glDisableClientState(GL_COLOR_ARRAY);
+ glPopMatrix();
+ }
+
+/*--------------------------------------------------------------------------*/
+// Draw animation
+//
+void CDrawUtility::Draw(const TSize &aScreenSize)
+ {
+ // Set OpenGL state
+ glEnable(GL_LIGHTING);
+ glEnable(GL_LIGHT0);
+ glDepthMask(GL_FALSE);
+ glDisable(GL_DEPTH_TEST);
+ glDisable(GL_TEXTURE_2D);
+ glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+ glEnableClientState(GL_NORMAL_ARRAY);
+ glPushMatrix();
+
+ // Set ortho to match screen size
+ glLoadIdentity();
+ glOrthof(0,aScreenSize.iWidth, aScreenSize.iHeight,0, -100,100);
+
+ // Move to top right corner
+ glTranslatef(aScreenSize.iWidth-40,40,0);
+
+ /*
+ // Calculate prespective values
+ GLfloat aspectRatio = (GLfloat)(aScreenSize.iWidth) / (GLfloat)(aScreenSize.iHeight);
+ 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);
+ glTranslatef(0,0,-40);
+ */
+ // Update light direction
+ float direction[4]={1, 0, -1, 0};
+ glLightfv(GL_LIGHT0,GL_POSITION, direction);
+ glColor4f(1,1,1, 1);
+ // Apply rotations
+ glRotatef(iAngleX, 1,0,0);
+ glRotatef(iAngleY, 0,1,0);
+ glRotatef(iAngleZ, 0,0,1);
+
+ // Draw tetrahedron
+ glVertexPointer(3,GL_FIXED,0, iVertices);
+ glNormalPointer(GL_FIXED,0, iNormals);
+ glDrawElements(GL_TRIANGLES, iTriCount*3,GL_UNSIGNED_SHORT,iIndices);
+
+ // Restore OpenGL state
+ glDepthMask(GL_TRUE);
+ glEnable(GL_DEPTH_TEST);
+ glDisable(GL_LIGHTING);
+ glEnable(GL_TEXTURE_2D);
+ glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+ glDisableClientState(GL_NORMAL_ARRAY);
+ glPopMatrix();
+ }
+#endif
+
+/*--------------------------------------------------------------------------*/
+// Draw moving arrow
+//
+void CDrawUtility::DrawMenuIndicators(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,
+ };
+ //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
+ TInt ArrowDistance=20;
+
+ glTranslatef(aScreenSize.iWidth - ArrowDistance, aScreenSize.iHeight/2, 0);
+
+ //glTranslatef(ArrowDistance, aScreenSize.iWidth/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, 0);
+
+ // Flip arrow around so it points to right
+ glRotatef(180,0,0,1);
+
+ 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();
+
+#ifdef ENABLE_ALPHA
+ // Remove alpha
+ glDisable(GL_BLEND);
+ glDisable(GL_ALPHA_TEST);
+#endif
+ // Restore OpenGL state
+ glDepthMask(GL_TRUE);
+ glEnable(GL_DEPTH_TEST);
+ glEnable(GL_TEXTURE_2D);
+ glShadeModel(GL_FLAT);
+ glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+ glDisableClientState(GL_COLOR_ARRAY);
+ glPopMatrix();
+ }
+
+/*--------------------------------------------------------------------------*/
+// Draw icon texture
+//
+void CDrawUtility::DrawIcon(const TSize &aScreenSize, GLuint aTexIndex)
+ {
+ if(aTexIndex != 0)
+ {
+ GLfixed vertices[8];
+ SetPictureVertices(vertices, 1);
+
+ glColor4f(1,1,1, 0.75);
+
+ // Set OpenGL state
+ glDepthMask(GL_FALSE);
+ glDisable(GL_DEPTH_TEST);
+ glEnable(GL_TEXTURE_2D);
+
+ //Enable alpha blending
+ glEnable(GL_BLEND);
+ glEnable(GL_ALPHA_TEST);
+ glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_COLOR);
+
+
+ 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
+ //glTranslatef(29, 29, 1);
+ glTranslatef(0, 0, 0);
+
+//#ifdef _S60_5x_ACCELEROMETER_
+ if(iContainer->GetScreenOrientation())
+ {
+ iRotationTarget = 0;
+ }
+ else
+ {
+ iRotationTarget = -90;
+ }
+ iContainer->Interpolate(iRotation, iRotationTarget, 0.25);
+ glRotatef(iRotation, 0,0,1);
+//#endif
+
+ glBindTexture(GL_TEXTURE_2D, aTexIndex);
+ glDrawArrays(GL_TRIANGLE_STRIP,0,4);
+
+ // Restore OpenGL state
+ glDepthMask(GL_TRUE);
+ glEnable(GL_DEPTH_TEST);
+ glEnable(GL_TEXTURE_2D);
+
+ glDisable(GL_BLEND);
+ glDisable(GL_ALPHA_TEST);
+
+ glDisableClientState(GL_VERTEX_ARRAY);
+ glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+
+ glPopMatrix();
+ }
+ }
+
+
+void CDrawUtility::DrawIcon2(const TSize &aScreenSize, GLuint aTexIndex, TReal aAlpha)
+ {
+
+ iScrAspectratio = (TReal)aScreenSize.iWidth/(TReal)aScreenSize.iHeight;
+
+ GLfixed vertices[8];
+ SetPictureVertices(vertices, 0.3);
+
+ //glColor4f(1,1,1, 1);
+ glColor4f(1,1,1, aAlpha);
+ // Set OpenGL state
+ glDepthMask(GL_FALSE);
+ glDisable(GL_DEPTH_TEST);
+ glEnable(GL_TEXTURE_2D);
+
+ //Enable alpha blending
+ glEnable(GL_BLEND);
+ glEnable(GL_ALPHA_TEST);
+ //glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_COLOR);
+ glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+ glVertexPointer( 2, GL_FIXED, 0, vertices );
+
+ glPushMatrix();
+
+ // Set ortho to match screen size
+ glLoadIdentity();
+ glOrthof(0,aScreenSize.iWidth, aScreenSize.iHeight,0, -50,50);
+
+
+ glTranslatef(iScrSize.iWidth-7, iScrSize.iHeight-25, 1);
+ iContainer->Interpolate(iRotation, iRotationTarget, 0.60);
+ //glRotatef(90, 0,0,1);
+ glBindTexture(GL_TEXTURE_2D, aTexIndex);
+ glScalef(0.5, 0.5, 0.5);
+ glDrawArrays(GL_TRIANGLE_STRIP,0,4);
+ glScalef(2, 2, 2);
+ glTranslatef(0, -iScrSize.iHeight+50, 1);
+ glScalef(0.5, 0.5, 0.5);
+ glBindTexture(GL_TEXTURE_2D, aTexIndex);
+ glDrawArrays(GL_TRIANGLE_STRIP,0,4);
+ glScalef(2, 2, 2);
+
+ // Restore OpenGL state
+ glDepthMask(GL_TRUE);
+ glEnable(GL_DEPTH_TEST);
+ glEnable(GL_TEXTURE_2D);
+
+ glDisable(GL_BLEND);
+ glDisable(GL_ALPHA_TEST);
+
+ //glDisable(GL_BLEND);
+ /*if(aShowLocationRect)
+ DrawZoomFrame(iRotationTarget);*/
+
+ glDisableClientState(GL_VERTEX_ARRAY);
+ glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+ glPopMatrix();
+
+ }