diff -r e1e28b0273b0 -r 93fff7023be8 AppSrc/CDrawGrid.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/AppSrc/CDrawGrid.cpp	Fri Oct 15 10:18:29 2010 +0900
@@ -0,0 +1,992 @@
+/*
+* 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
+    glTranslatef(-iDrawGridX, KSpacingY+(iDrawGridY-KSpacingY)/centerOffset, iDrawGridZoom);
+#endif
+    
+    //OpenGl Vertex data
+    GLfixed vertices[8];
+    glVertexPointer( 2, GL_FIXED, 0, vertices );
+    
+    //Bind into a null picture
+    //iContainer->iCurrentBindedIndex = iContainer->iLoadingTextureIndex;
+    //iContainer->iLoadingTextureIndex = 0;
+    //glBindTexture( GL_TEXTURE_2D, iContainer->iLoadingTextureIndex);
+    glBindTexture( GL_TEXTURE_2D, 0);
+    
+       
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+   	
+    // Set gray color for pictures that are not loaded yet
+    glColor4f(0.3,0.3,0.3, 1);
+    
+    TInt drawMax = iContainer->GetCurrentIndex()+KDrawLimit;
+    TInt drawMin = iContainer->GetCurrentIndex()-KDrawLimit;
+
+    CImageData* currentImageData = NULL;
+    TGridMode gridMode = iContainer->iIEngine->GetImageList().GetGridMode();
+    if (gridMode != EGridModeTime)      
+        currentImageData = iContainer->iIEngine->GetImageData(iContainer->GetCurrentIndex());
+    
+    //This loop draws all the textures in the grid ------------------------------->
+    for(TInt i2=0; i2<iContainer->iIEngine->GetTotalNumOfImages(); i2++)
+        {
+        TInt i = (i2 + iContainer->GetCurrentIndex() + 1) % iContainer->iIEngine->GetTotalNumOfImages();
+        CImageData* imageData = iContainer->iIEngine->GetImageData(i);
+        
+        //If we are in same picture index, ie. not moving, draw both sides equally
+        if(drawMax > iContainer->iIEngine->GetTotalNumOfImages()-1)
+            drawMax = iContainer->iIEngine->GetTotalNumOfImages()-1;
+        if(drawMin < 0)
+            drawMin = 0;
+            
+        //Do not draw all images, just enough to fill the screen
+        if((Abs(imageData->iGridData.iRotationAngle-imageData->iGridData.iTargetRotationAngle) > 0.1) || //Draw all all images in grid if rotated
+           (i>=drawMin && i<=drawMax))
+            {
+            // Calculate current coordinates
+            //TInt x = i/iContainer->iGridSizeY;
+            //TInt y = -(i%iContainer->iGridSizeY);// Y axis is inverted
+            float z=0;
+            //float scale=1;
+            iScaleTarget = 1;
+            
+            
+            //Highlight by scaling up selected picture on Grid
+            if(iContainer->GetCurrentIndex()==i)
+                {
+                z=0.3;
+                iScaleTarget = 1.5;
+                }
+
+            TBool dim = EFalse; //(currentImageData && !currentImageData->IsSamePath(*imageData));            
+            //BubbleEffect(x, y, z);
+            
+            //Zoom out the grid if "camera target" is far away from current position >>>
+            //if (Abs(iDrawGridX-iDrawGridTargetX) > 10*KSpacingX)
+#ifdef MOMENTUM_MOVE
+            float absDeltaX = Abs(iDrawGridXY.iX-iDrawGridTargetXY.iX);
+            if((!iContainer->iMomentumMove && absDeltaX > 2*CImagicContainerBrowser::KSpacingX) ||
+               ( iContainer->iMomentumMove && absDeltaX > 5*CImagicContainerBrowser::KSpacingX))
+#else
+            if(Abs(iDrawGridX-iDrawGridTargetX) > 2*KSpacingX)
+#endif
+                {
+                z=KTargetZCoord;
+                iContainer->Interpolate(imageData->iGridData.iZ, z, 0.05);
+                }    
+            else
+                {
+                iContainer->Interpolate(imageData->iGridData.iZ, z, 0.05);
+                }
+            
+            iContainer->Interpolate(imageData->iGridData.iScale, iScaleTarget, 0.23);
+            //Zoom out the grid if "camera target" is far away from current position <<<
+            
+            //Rotate picture in Grid if needed
+            iContainer->HandleRotation(imageData->iGridData.iRotationAngle, imageData->iGridData.iTargetRotationAngle);
+            
+            //Calculate new picture vertices to fix picture aspect ratio
+            iContainer->SetPictureVertices(imageData, vertices);
+            
+            //Move camera to picture position and rotate and scale it
+            glPushMatrix();    
+            glTranslatef(imageData->iGridData.iX, imageData->iGridData.iY, imageData->iGridData.iZ);// - (dim ? 1.0 : 0));
+            glRotatef(imageData->iGridData.iRotationAngle, 0,0,1);
+            TReal scale = imageData->iGridData.iScale;
+            glScalef(scale, scale, scale);
+            
+#ifdef SHADOW_PHOTOS
+            // Draw shadow behind image
+            glPushMatrix();
+            glBindTexture( GL_TEXTURE_2D, iContainer->iShadowTextureIndex);
+            glTranslatef(0, 0, -0.15);
+            glScalef(1.2, 1.2, 1);
+            glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+            glPopMatrix();
+#endif                     
+            
+#ifdef DRAW_FRAME
+            // Draw frame around selected image
+            if (iContainer->GetCurrentIndex()==i)
+                DrawFrame(i);
+#endif
+                    
+            // Calculate color for not loaded picture, more far from selection-> darker box
+            float color = 
+#ifdef EMPTY_IMAGE_AS_WIREFRAME
+                0.05 + 0.2/
+#else
+                1.0/
+#endif                
+                (Abs(iDrawGridXY.iX - imageData->iGridData.iX)/2 + .2);
+            if (color > 0.5)
+                color = 0.5;
+            glColor4f(color,color,color, 1);
+            
+            //Bind to a new picture only if needed, ie. we really have new picture
+            if(imageData->iGridData.iGlLQ128TextIndex != iLastGridTexture ||
+               imageData->iGridData.iGlLQ32TextIndex != iLastGridTexture)
+                {
+                if(imageData->iGridData.iGlLQ128TextIndex)
+                    iLastGridTexture = imageData->iGridData.iGlLQ128TextIndex;
+                else if(imageData->iGridData.iGlLQ32TextIndex)
+                    iLastGridTexture = imageData->iGridData.iGlLQ32TextIndex;
+                else
+                    iLastGridTexture = iContainer->iLoadingTextureIndex;
+                
+                iContainer->iCurrentBindedIndex = iLastGridTexture;
+                glBindTexture( GL_TEXTURE_2D, iLastGridTexture);
+                
+                // Picture is loaded, draw it with white color
+                if (iLastGridTexture)  
+                    {
+                    // Draw as solid black frame
+                    if (dim)
+                        glColor4f(0.4,0.4,0.4, 1);
+                    else
+                        glColor4f(1,1,1, 1);
+                    }
+                }
+            
+            // Draw image
+#ifdef EMPTY_IMAGE_AS_WIREFRAME            
+            if (iLastGridTexture == 0 && iContainer->GetCurrentIndex() != i)
+                {
+                GLfixed p;
+                p = vertices[6]; vertices[6] = vertices[4]; vertices[4] = p;
+                p = vertices[7]; vertices[7] = vertices[5]; vertices[5] = p;
+                glLineWidth(1.8f);  // TODO: depend on resolution
+                glDrawArrays(GL_LINE_LOOP,0,4);
+                p = vertices[6]; vertices[6] = vertices[4]; vertices[4] = p;
+                p = vertices[7]; vertices[7] = vertices[5]; vertices[5] = p;
+                }
+            else
+                {
+                // Draw as solid black frame
+                if (iLastGridTexture == 0)
+                    glColor4f(0,0,0, 1);
+#endif                
+                glDrawArrays(GL_TRIANGLE_STRIP,0,4);
+#ifdef EMPTY_IMAGE_AS_WIREFRAME                
+                }
+#endif            
+           
+            glPopMatrix();
+            }//if
+        
+        //EGLint err = eglGetError();
+        EGLint err = glGetError();
+        //if(err != EGL_SUCCESS)
+        while(err != GL_NO_ERROR)
+            {
+            CImageData* data = iContainer->iIEngine->GetImageData(i);
+            //Delete all textures for this index just in case
+            if(data->iGridData.iGlLQ128TextIndex)
+                glDeleteTextures(1, &data->iGridData.iGlLQ128TextIndex);data->iGridData.iGlLQ32TextIndex = 0;
+            if(data->iGridData.iGlLQ32TextIndex)
+                glDeleteTextures(1, &data->iGridData.iGlLQ32TextIndex);data->iGridData.iGlLQ128TextIndex = 0;
+            if(data->iGridData.iGlHQ512TextIndex)
+                glDeleteTextures(1, &data->iGridData.iGlHQ512TextIndex);data->iGridData.iGlHQ512TextIndex = 0;
+            if(data->iGridData.iGlSuperHQTextIndex)
+                glDeleteTextures(1, &data->iGridData.iGlSuperHQTextIndex);data->iGridData.iGlSuperHQTextIndex = 0;
+            
+            err = eglGetError();
+            }
+                        
+        }//for
+    
+#if 0
+    if(iMenuAlpha < 1)
+        {
+        iMenuAlpha-=0.15;
+        if(iMenuAlpha < 0)
+            iMenuAlpha = 0;
+        }
+
+    iContainer->iDrawUtility->DrawIcon2(iContainer->Size(), iContainer->iMenuTextureIndex, iMenuAlpha);
+#endif
+    
+    iContainer->DynamicLoadingL();
+    }
+
+
+TBool CDrawGrid::IsDrawingNeededGrid()
+    {
+    
+    CImageData* imageData = iContainer->iIEngine->GetImageData(iContainer->GetCurrentIndex());
+    
+    iContainer->SetMinMagFilterLinear(EFalse);
+#if 0
+    if(iMenuAlpha != 0)
+        {
+        return ETrue;
+        }
+#endif
+    if(Abs(iPerspectiveCurrent) < CImagicContainerBrowser::KAngle2Start128Loading && Abs(iPerspectiveCurrent) > 0.001)
+        {
+        //DP0_IMAGIC(_L("CDrawGrid::IsDrawingNeededGrid #0"));
+        iContainer->iDynamicLoadingOn = ETrue;
+        }
+    
+    
+    //Make sure that all visible images are rotated
+    //this causes too much processor load
+    /*for(TInt i=0; i<=CImagicContainerBrowser::K128TNImageBuffer; i++)
+        {
+        for(TInt j=0; j<2; j++)
+            {
+            TInt index = iContainer->GetCurrentIndex() + (j ?  i : -i);
+            
+            CImageData* imageData = iContainer->iIEngine->GetImageData(index);
+            
+            if(imageData != NULL)
+                if(Abs(imageData->iGridData.iRotationAngle - imageData->iGridData.iTargetRotationAngle) > 0.01)
+                    {
+                    DP0_IMAGIC(_L("CDrawGrid::IsDrawingNeededGrid #0.1"));
+                    return ETrue;
+                    }
+                else if(imageData->iGridData.iRotationAngle != imageData->iGridData.iTargetRotationAngle)
+                    {
+                    DP0_IMAGIC(_L("CDrawGrid::IsDrawingNeededGrid #0.2"));
+                    imageData->iGridData.iRotationAngle = imageData->iGridData.iTargetRotationAngle;
+                    return ETrue;
+                    }
+            }
+        }*/
+    
+    //CImageData* imageData = iContainer->iIEngine->GetImageData(iContainer->GetCurrentIndex());
+    
+    if(imageData)
+        if(Abs(imageData->iGridData.iScale - iScaleTarget) > 0.1)
+            {
+            return ETrue;
+            }
+        else if(imageData->iGridData.iScale != iScaleTarget)
+            {
+            imageData->iGridData.iScale = iScaleTarget;
+            return ETrue;
+            }
+    
+    
+#ifdef ENABLE_DISPLAY_ROTATION
+    if(Abs(iContainer->GetDisplayRotAngle() - iContainer->GetDisplayRotTargetAngle()) > 1)
+        {
+        DP0_IMAGIC(_L("CDrawGrid::IsDrawingNeededGrid #2"));
+        return ETrue;
+        }
+    else if(iContainer->GetDisplayRotAngle() != iContainer->GetDisplayRotTargetAngle())
+        {
+        iContainer->SetDisplayRotAngle(iContainer->GetDisplayRotTargetAngle());
+        return ETrue;
+        }
+#endif
+    
+    if(imageData)
+        if(Abs(imageData->iGridData.iRotationAngle-imageData->iGridData.iTargetRotationAngle) > 1)
+            {
+            DP0_IMAGIC(_L("CDrawGrid::IsDrawingNeededGrid #3"));
+            return ETrue;
+            }
+        else if(imageData->iGridData.iRotationAngle != imageData->iGridData.iTargetRotationAngle)
+            {
+            imageData->iGridData.iRotationAngle = imageData->iGridData.iTargetRotationAngle;
+            //iContainer->iDrawNow = ETrue;
+            return ETrue;
+            }
+    
+#ifdef ENABLE_GRID_ZOOM
+    if(Abs(iDrawGridZoom - iDrawGridTargetZoom) > 0.01)
+        {
+        DP0_IMAGIC(_L("CDrawGrid::IsDrawingNeededGrid #4"));
+        return ETrue;
+        }
+#endif
+    
+    if(Abs(iDrawGridXY.iX - iDrawGridTargetXY.iX) > 0.02)
+        {
+        DP0_IMAGIC(_L("CDrawGrid::IsDrawingNeededGrid #5"));
+        return ETrue;
+        }
+    else if(iDrawGridXY.iX != iDrawGridTargetXY.iX)
+        {
+        iDrawGridXY.iX = iDrawGridTargetXY.iX;
+        }
+    
+    if(Abs(iDrawGridXY.iY - iDrawGridTargetXY.iY) > 0.02)
+        {
+        DP0_IMAGIC(_L("CDrawGrid::IsDrawingNeededGrid #6"));
+        return ETrue;
+        }
+    else if(iDrawGridXY.iY != iDrawGridTargetXY.iY)
+        {
+        iDrawGridXY.iY = iDrawGridTargetXY.iY;
+        }
+    
+    if(Abs(iPerspectiveCurrent - iTargetPerspective) > 0.1)
+        {
+        DP0_IMAGIC(_L("CDrawGrid::IsDrawingNeededGrid #7"));
+        return ETrue;
+        }
+    else if(iPerspectiveCurrent != iTargetPerspective)
+        {
+        DP0_IMAGIC(_L("CDrawGrid::IsDrawingNeededGrid #7.1"));
+        iPerspectiveCurrent = iTargetPerspective;
+        return ETrue;
+        }
+    
+    if(iContainer->iDrawNow)
+        {
+        DP0_IMAGIC(_L("CDrawGrid::IsDrawingNeededGrid #1"));
+        iContainer->iDrawNow = EFalse;
+        return ETrue;
+        }
+    
+    return EFalse;
+    }
+
+
+void CDrawGrid::MovingDirection()
+    {
+    if(iContainer->GetPrevIndex() < iContainer->GetCurrentIndex())
+        {
+        iMovingRight = ETrue;
+        iMovingLeft = EFalse;
+        }
+    else if(iContainer->GetPrevIndex() > iContainer->GetCurrentIndex())
+        {
+        iMovingLeft = ETrue;
+        iMovingRight = EFalse;
+        }
+    else if(iContainer->GetPrevIndex() == iContainer->GetCurrentIndex())
+        {
+        iMovingRight = EFalse; 
+        iMovingLeft = EFalse;
+        }
+    }
+
+void CDrawGrid::DisplayDate()
+    {
+    CImageData* imageData = iContainer->iIEngine->GetImageData(iContainer->GetCurrentIndex());
+    
+    if(imageData)
+        {
+        TDateTime dateTime = imageData->GetCreatedTime().DateTime();
+        if(iPrevDateTime.Month() != dateTime.Month())
+            {
+            TMonth month = dateTime.Month();
+            iContainer->iImagicAppUi->GetImagicUtils()->DisplayYearAndMonth(0, dateTime);
+            }
+        iPrevDateTime = dateTime;
+        }
+    }
+
+/*----------------------------------------------------------------------*/
+// Calculates widht and height with aspect ratio
+//
+void CDrawGrid::DrawFrame(TInt aIndex)
+    {
+    // Draw frame around selected image
+    glPushMatrix();
+    glDisable(GL_TEXTURE_2D);
+    
+    glDisable(GL_DEPTH_TEST);
+    
+    //Frame size
+    float scale=1.09;        
+#ifdef FRAME_COLOR_CHANGE
+    if(iSelectionFrameColor >= 1.0)
+        iSelectionFrameColor-=0.05;
+        
+    if(iSelectionFrameColor <= 0.3)
+        iSelectionFrameColor+= 0.05;
+
+    if(iTNCreationComplete)
+        glColor4f(iSelectionFrameColor,iSelectionFrameColor,iSelectionFrameColor, 1);
+    else
+        glColor4f(1,iSelectionFrameColor,iSelectionFrameColor, 1);
+#else
+#ifdef SHADOW_PHOTOS
+    glColor4f(1,0,0, 1);        // red frame
+#else    
+    glColor4f(1,1,1, 1);        // white frame
+#endif    
+#endif
+    
+    glTranslatef(0,0,-0.03);
+    glScalef(scale,scale,scale);
+    glDrawArrays(GL_TRIANGLE_STRIP,0,4);
+    
+    //glDisable(GL_BLEND);
+    //glDisable(GL_DEPTH_TEST);
+    
+    glEnable(GL_TEXTURE_2D);
+    glPopMatrix();
+    }
+
+/*----------------------------------------------------------------------*/
+// Calculates widht and height with aspect ratio
+//
+void CDrawGrid::BubbleEffect(TInt& x, TInt& y, float& z)
+    {
+    if(iBubbleEffect)
+        {
+        // Selected image in coordinates x,y
+        TInt selectedX = iContainer->GetCurrentIndex()/3 /*iGridSizeY*/;
+        TInt selectedY =- (iContainer->GetCurrentIndex()%3 /*iGridSizeY*/);
+                    
+        // Distance to selected
+        iDistanceX = selectedX-x;
+        iDistanceY = selectedY-y;
+        // Squared
+        if(iDistanceX<0) iDistanceX*= -1;
+        if(iDistanceY<0) iDistanceY*= -1;
+        
+        // Distance
+        iDiff=iDistanceX+iDistanceY;
+        // Convert distance to depth
+        // http://en.wikipedia.org/wiki/Gaussian_function
+        if (iDiff==0) z=5.0;
+        if (iDiff==1) z=4.2;
+        if (iDiff==2) z=3.4;
+        if (iDiff==3) z=2.1;
+        if (iDiff==4) z=1.3;
+        if (iDiff==5) z=0.8;
+        if (iDiff==6) z=0.4;
+        if (iDiff==7) z=0.3;
+        if (iDiff>7) z=0.3;
+        //if (iDiff==8) z=0.1;
+        //if (iDiff==9) z=0.05;
+        //if (iDiff==10) z=0.01;
+        //if (iDiff>10) z=0;
+        }
+    }
+
+