--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/AppSrc/CDrawFaceBrowsing.cpp Fri Oct 15 10:18:29 2010 +0900
@@ -0,0 +1,724 @@
+/*
+* 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;
+ }
+ else if(iDrawX != iDrawTargetX)
+ {
+ DP0_IMAGIC(_L("CDrawFaceBrowsing::IsDrawingNeededOneByOne - 11.1"));
+ iDrawX = iDrawTargetX;
+ //iContainer->iDrawOneMoreTime = ETrue;
+ iContainer->SetMinMagFilterLinear(ETrue);
+ return ETrue;
+ }
+
+ if(Abs(iDrawY-iDrawTargetY) > 0.001)
+ {
+ DP0_IMAGIC(_L("CDrawFaceBrowsing::IsDrawingNeededOneByOne - 12"));
+ iContainer->SetMinMagFilterLinear(EFalse);
+ return ETrue;
+ }
+ else if(iDrawY != iDrawTargetY)
+ {
+ DP0_IMAGIC(_L("CDrawFaceBrowsing::IsDrawingNeededOneByOne - 12.1"));
+ iDrawY = iDrawTargetY;
+ //iContainer->iDrawOneMoreTime = ETrue;
+ iContainer->SetMinMagFilterLinear(ETrue);
+ return ETrue;
+ }
+ }
+
+ /*if(iContainer->iDrawOneMoreTime)
+ {
+ DP0_IMAGIC(_L("CDrawFaceBrowsing::IsDrawingNeededOneByOne - 14"));
+ iContainer->iDrawOneMoreTime = EFalse;
+ iContainer->SetMinMagFilterLinear(ETrue);//Draw one more time to change for Linear rendering mode
+ return ETrue;
+ }*/
+
+ if(!iContainer->iMagFilterLinear)
+ {
+ DP0_IMAGIC(_L("CDrawFaceBrowsing::IsDrawingNeededOneByOne - 15"));
+ iContainer->SetMinMagFilterLinear(ETrue);
+ //iContainer->iDrawOneMoreTime = ETrue;
+ }
+
+ if(iContainer->iDrawNow)
+ {
+ DP0_IMAGIC(_L("CDrawFaceBrowsing::IsDrawingNeededOneByOne - 1"));
+ /*if(iContainer->iMagGlassOn)
+ {
+ if(!iContainer->iTouchPointThreshold)//moved >2 pixel
+ iContainer->SetMinMagFilterLinear(ETrue);
+ else
+ iContainer->SetMinMagFilterLinear(EFalse);
+ }
+ else*/
+ {
+ iContainer->SetMinMagFilterLinear(ETrue);
+ }
+
+ //iDrawOneMoreTime = ETrue;
+ iContainer->iDrawNow = EFalse;
+ return ETrue;
+ }
+
+ return EFalse;
+ }
+
+
+/*----------------------------------------------------------------------*/
+// Calculate coords coords from alogorith to OpenGL -0.5 - +0.5 coords
+//
+FloatCoords CDrawFaceBrowsing::ConvertCoordsFromAlgo2OGl(const TInt aFaceIndex)
+ {
+ CImageData* imageData = iContainer->iIEngine->GetImageData(iContainer->GetCurrentIndex());
+
+ TInt pictureWidth, pictureHeigth;
+ //We use always qvga image for Face detection
+ pictureWidth=320;
+ pictureHeigth=320;
+ //landscape
+ if(imageData->GetAspectRatio() > 1)
+ pictureHeigth=pictureWidth/imageData->GetAspectRatio();
+ else//portrait
+ pictureWidth=pictureHeigth*imageData->GetAspectRatio();
+
+ //calculate midpoint from face rect
+ TInt xAvegCoord = (iCoordinates[aFaceIndex].iTl.iX + iCoordinates[aFaceIndex].iBr.iX)/2;
+ TInt yAvegCoord = (iCoordinates[aFaceIndex].iTl.iY + iCoordinates[aFaceIndex].iBr.iY)/2;
+ //and then convert coordinate zero point to center of screen
+ xAvegCoord-=(pictureWidth/2);
+ yAvegCoord-=(pictureHeigth/2);
+
+ //Calculate coords coords from alogorith to OpenGL -0.5 - +0.5 coords and fill the array
+ FloatCoords tmp;
+ if(imageData->GetAspectRatio() > 1)
+ {
+ tmp.iX = (xAvegCoord * 0.5) / (pictureWidth/2);
+ tmp.iY = (yAvegCoord * (0.5/imageData->GetAspectRatio())) / (pictureHeigth/2);
+ }
+ else//portrait
+ {
+ tmp.iX = (xAvegCoord * (0.5*imageData->GetAspectRatio())) / (pictureWidth/2);
+ tmp.iY = (yAvegCoord * 0.5) / (pictureHeigth/2);
+ }
+
+ return tmp;
+ }
+
+
+/*----------------------------------------------------------------------*/
+// Draws one by one view
+//
+void CDrawFaceBrowsing::GetFaceCoordinatesL(TRect& aRect, TFileName& aFilename)
+ {
+ iContainer->iImagicAppUi->GetEngine()->GetFileNameL(iContainer->GetCurrentIndex(), ESize512x512, aFilename);
+
+ if(iFaceNro < iCoordinates.Count() && iFaceNro >= 0)
+ {
+ aRect.iTl.iX = iCoordinates[iFaceNro].iTl.iX;
+ aRect.iTl.iY = iCoordinates[iFaceNro].iTl.iY;
+ aRect.iBr.iX = iCoordinates[iFaceNro].iBr.iX;
+ aRect.iBr.iY = iCoordinates[iFaceNro].iBr.iY;
+ }
+ }
+
+/*----------------------------------------------------------------------*/
+// Draws one by one view
+//
+TInt CDrawFaceBrowsing::GetNumberOfFaces()
+ {
+ return iCoordinates.Count();
+ }
+
+/*----------------------------------------------------------------------*/
+// Draws one by one view
+//
+void CDrawFaceBrowsing::SetCurrentFaceNro(TInt aNro)
+ {
+ iFaceNro = aNro;
+
+ if(iFaceNro < 0)
+ iFaceNro = 0;
+ if(iFaceNro >= iCoordinates.Count())
+ iFaceNro = 0;
+ }
+
+/*----------------------------------------------------------------------*/
+// Gets current face nro
+//
+TInt CDrawFaceBrowsing::GetCurrentFaceNro()
+ {
+ return iFaceNro;
+ }
+
+void CDrawFaceBrowsing::SetFaceCoords(RArray<TRect>& aCoordinates)
+ {
+ ClearFaceArray();
+
+ for(TInt i = 0; i < aCoordinates.Count(); i++)
+ {
+ iCoordinates.Append(aCoordinates[i]);
+ }
+
+ iDrawFBTargetZoom = 0;
+ iFaceNro = 0;
+ }
+
+void CDrawFaceBrowsing::ClearFaceArray()
+ {
+ //iCoordinates.Reset();
+ TInt tmp = iCoordinates.Count();
+ //delete array if we had old data there
+ for(TInt i = 0; i < tmp; i++)
+ {
+ iCoordinates.Remove(0);
+ }
+
+ tmp = iFloatCoordinates.Count();
+ for(TInt i = 0; i < tmp; i++)
+ {
+ iFloatCoordinates.Remove(0);
+ }
+ iCoordIndex=0;
+ }
+
+TInt CDrawFaceBrowsing::GetFaceCount()
+ {
+ return iCoordinates.Count();
+ }
+
+void CDrawFaceBrowsing::IncFaceNumber()
+ {
+ iFaceNro++;
+ }
+
+void CDrawFaceBrowsing::DecFaceNumber()
+ {
+ iFaceNro--;
+ }