diff -r e1e28b0273b0 -r 93fff7023be8 AppSrc/ImagicContainerBrowser.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/AppSrc/ImagicContainerBrowser.cpp Fri Oct 15 10:18:29 2010 +0900 @@ -0,0 +1,3723 @@ +/* +* 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 FILES +#include "ImagicContainerBrowser.h" +#include "ImagicViewBrowser.h" +#include "TextureLoader.h" + +#include +#include +#include +#include +#include +#include "Imagic.hrh" +#include "project.h" +#include +#include "DrawUtility.h" +#include "ImagicConsts.h" +#include + + +const float CImagicContainerBrowser::KMinOneByOneZoom = 1; +const float CImagicContainerBrowser::KMaxOneByOneZoom = 4.2; +const TInt CImagicContainerBrowser::KDoubleTapZoomOneByOne1 = KMinOneByOneZoom; +const TInt CImagicContainerBrowser::KDoubleTapZoomOneByOne2 = KMaxOneByOneZoom*0.71; +const TReal CImagicContainerBrowser::KAngle2Start128Loading = 3; +const TReal CImagicContainerBrowser::KAngle2Start128LoadingHwAcc = 6; +const TInt CImagicContainerBrowser::KGridSizeY = 3; + +/*const*/ TInt CImagicContainerBrowser::K512TNImageBuffer = 1;//number of pictures to be loaded when using dynamic loading in grid +const TInt CImagicContainerBrowser::K128TNImageBuffer = 8;//number of pictures to be loaded when using dynamic loading in grid +/*const*/ TInt CImagicContainerBrowser::K32TNImageBuffer = 300;//number of pictures to be loaded when using dynamic loading in grid +/*const*/ TInt CImagicContainerBrowser::K32TNImageUnLoadBuffer = K32TNImageBuffer*3; + +const TReal KLoadingImageAspectRatio = 1.23; +const TInt KNumOf32ThumbsLoadedBefore128Thumb = 10; + +#ifdef ADAPTIVE_FRAMERATE +#ifdef __WINS__ +const TInt KDisplayDrawFreq = 20000; +const TInt KPowerSaveDisplayDrawFreq = 20000; +const TInt KWaitTicksAfterDraw = 0; +#else +const TInt KDisplayDrawFreq = 60000; +const TInt KPowerSaveDisplayDrawFreq = 135000; +const TInt KWaitTicksAfterDraw = 0; +#endif +#else +const TInt KDisplayDrawFreq = 60000;//display update freq in micro secons, 60.000us = 16.7FPS +const TInt KPowerSaveDisplayDrawFreq = 95000;//display update freq in micro secons, 12.5FPS +#endif + +const float CImagicContainerBrowser::KSpacingX = 1.2;// Picture spacing in the grid +const float CImagicContainerBrowser::KSpacingY = 1.15;// Picture spacing in the grid +// Space between pictures in one by one +const float CImagicContainerBrowser::KOneByOneSpacing=1.1; + +const float KFindFaceSearchRange = 0.01; +const TInt KPowerSavePeriodicDelay = 300000;//0.3s +const TInt KTouchDelay = 1000000;//1s. longer because it scrolls even after user action +const TInt KPowerSavePeriodicInterval = 40000000;//0.4s +const TReal KInitDrawZoom = 0.1; + +#define INT_MAX ((int)(((unsigned int)-1)>>1)) +// macro to check if OneByOne view is zooming in. +0.01f for safety +#define IS_NOT_IN_ZOOM_ONEBYONE ((iDrawOneByOne->GetDrawOneByOneTargetZoom()) < (KDoubleTapZoomOneByOne1 + 0.01f)) +#define IS_ALMOST_ZERO (0.001) + +const float KUpdatesPerSecond = 1.0/15; + +//App UI Feature definition flags +#define USE_LOW_DRAW_SPEED_WHILE_LOADING + + +// Texture coordinate data +const GLfixed CImagicContainerBrowser::iGlobalTexCoords[] = + { + //bitmap has to be flipped over + 0, 1<<16, + 1<<16, 1<<16, + 0, 0, + 1<<16, 0 + }; + + + +// ================= MEMBER FUNCTIONS ======================= + +// --------------------------------------------------------- +// CImagicContainerBrowser::ConstructL(const TRect& aRect) +// EPOC two phased constructor +// --------------------------------------------------------- +// +void CImagicContainerBrowser::ConstructL(CImagicAppUi* aImagicAppUi, CImagicViewBrowser* aView, const TRect& /*aRect*/) + { + DP0_IMAGIC(_L("CImagicContainerBrowser::ConstructL++")); + + iDisplayDrawFreq = KDisplayDrawFreq; + iUserInputGiven = EFalse; + iDeleteTextures = EFalse; + iLastEventFromKeys = EFalse; + + iImagicAppUi = aImagicAppUi; + iIEngine = iImagicAppUi->GetEngine(); + iView = aView; + + iDrawGrid = CDrawGrid::NewL(this, iCurrentIndex); + iDrawOneByOne = CDrawOneByOne::NewL(this, iCurrentIndex); + iDrawFaceBrowsing = CDrawFaceBrowsing::NewL(this, iCurrentIndex); + + +#ifdef ADAPTIVE_FRAMERATE + iWaitDrawTicks = 0; +#endif + + //iPlayedWithDrag = EFalse; +#ifdef HOLD_SELECTION_ONDRAG + iHoldSelection = EFalse; + iOneByOneSlideByDrag = EFalse; +#endif +#ifdef MOMENTUM_MOVE + iMomentumMove = EFalse; +#endif +#ifdef RD_FACEFRAME + //iDrawFaceFrame = EFalse; +#endif + + // Create the native window + CreateWindowL(); + // Take the whole screen into use + SetExtentToWholeScreen(); + + // If the device supports touch, construct long tap detector + if ( AknLayoutUtils::PenEnabled() ) + { + // Enable drag events listening + EnableDragEvents(); + +#ifdef USE_AVKON_LONGTAP_DETECTOR + // Enable long tap detection + iLongTapDetector = CAknLongTapDetector::NewL(this); + iLongTapDetector->SetTimeDelayBeforeAnimation(200000); // Delay before animation is set to 2 seconds in this example. Defualt is 0.15 seconds + iLongTapDetector->SetLongTapDelay(400000); // Long tap delay is set to 5 seconds in this example. Defualt is 0.8 seconds +#endif +#ifdef USE_AVKON_TACTILE_FEEDBACK + iTouchFeedBack = MTouchFeedback::Instance(); + iTouchFeedBack->SetFeedbackEnabledForThisApp(ETrue); +#endif + + iGesture = CGesture::NewL(this); +// iGesture->SetThresholdOfTap(10); // tap must have movement with 10 pixels +// iGesture->SetThresholdOfMovement(50); // experimental value on Ivalo +// iGesture->SetThresholdOfFastMove(100); // fast move if > 100 pixel/100ms +// iGesture->SetMonitoringTime(100000); // 100ms + } + else + { +#ifdef USE_AVKON_LONGTAP_DETECTOR + iLongTapDetector = NULL; +#endif + iGesture = NULL; + } + + //Activate view + ActivateL(); + + //Create critical section + iDrawLock.CreateLocal(); + + //Create an active object for animating the scene, keep priority high! + //EPriorityIdle, EPriorityLow, EPriorityStandard, EPriorityUserInput, EPriorityHigh + iPeriodic = CPeriodic::NewL( CActive::EPriorityUserInput); +#ifdef USE_LOW_DRAW_SPEED_WHILE_LOADING + iPowerSavePeriodic = CPeriodic::NewL( CActive::EPriorityUserInput);//keep this high, othervice can not quarantee that draw freq drop is getting run time + iPowerSavePeriodic->Start(KPowerSavePeriodicDelay, KPowerSavePeriodicInterval, TCallBack( CImagicContainerBrowser::PowerSaveCallBack, this ) ); +#endif + + // Initialize OpenGL + InitAfterPowerSaveL(); + + //Create texture loader + iTextureLoader = new (ELeave) CTextureLoader(iImagicAppUi, this, iView, &iDrawLock); + iTextureLoader->ConstructL(); + + iTextureLoader->CreateIconTextures(); + + iDisplayRotation = 0;//Set initial display rotation to 0. This controls the whole display rotation, not single picture + iDisplayRotationTarget = 0;//Set initial display rotation to 0 + + iDrawFunction = EGrid; + iPreferHighResLoading = EFalse; + iDrawGrid->InitDrawGrid(); + + //iSelector = CRemConInterfaceSelector::NewL(); + //iTarget = CRemConCoreApiTarget::NewL( *iSelector, *this ); + //iSelector->OpenTargetL(); + + + //Create Draw utility class + iDrawUtility = CDrawUtility::NewL(this); + + DP0_IMAGIC(_L("CImagicContainerBrowser::ConstructL--")); + } + +void CImagicContainerBrowser::InitAfterPowerSaveL() + { + OpenGLInitL(); + InitL(); + + iDrawOnes = 0; + // Load loading icon + iLoadingTextureIndex = 0; +#ifdef EMPTY_IMAGE_AS_BMP + CFbsBitmap loadingBitmap; + TInt error = loadingBitmap.Load(KLoadingFileName); + if (error == KErrNone) + { + iLoadingTextureIndex = iTextureLoader->CreateTexture(&loadingBitmap, EFalse); + } +#endif + +#if 0 + iExitTextureIndex = 0; + CFbsBitmap exitBitmap; + error = exitBitmap.Load(KExitFileName); + if (error == KErrNone) + { + iExitTextureIndex = iTextureLoader->CreateTexture(&exitBitmap, EFalse); + } + + iMenuTextureIndex = 0; + CFbsBitmap menuBitmap; + error = menuBitmap.Load(KMenuFileName); + if (error == KErrNone) + { + iMenuTextureIndex = iTextureLoader->CreateTexture(&menuBitmap, EFalse); + } +#endif + +#ifdef SHADOW_PHOTOS + iShadowTextureIndex = 0; + CFbsBitmap shadowBitmap; + error = shadowBitmap.Load(KShadowFileName); + if (error == KErrNone) + { + iShadowTextureIndex = iTextureLoader->CreateTexture(&shadowBitmap, EFalse); + } +#endif + + } + +void CImagicContainerBrowser::InitL() + { + DP0_IMAGIC(_L("CImagicContainerBrowser::GridDataInit++")); + +#ifdef _ACCELEROMETER_SUPPORTED_ + //iDeviceOrientation = TSensrvOrientationData::EOrientationDisplayRightUp;//Landscape + //iDeviceOrientation = TImagicDeviceOrientation::EOrientationDisplayRightUp;//Portrait + //iDeviceOrientation = 3;//EOrientationDisplayRightUp = Landscape + iDeviceOrientation = iIEngine->GetDeviceOrientation(); +#endif + + DP1_IMAGIC(_L("CImagicContainerBrowser::GridDataInit - Device orientation: %d"),iDeviceOrientation); + + iScreenImmeadetaUpdate = EFalse; + + iDrawNow = EFalse; + iDynamicLoadingOn = ETrue; + + iNewImageAdded = EFalse; + iPreferHighResLoading = EFalse; + + if(iImagicAppUi->GetImageIndex()) + iCurrentIndex = iImagicAppUi->GetImageIndex(); + else + iCurrentIndex = 0; + + //Read user settings from database <-------------------- + + //Set default draw function + iDrawFunction = EGrid; + + //Init key data here + ResetKeyData(); + + DP0_IMAGIC(_L("CImagicContainerBrowser::GridDataInit--")); + } + + + +void CImagicContainerBrowser::OpenGLInitL() + { + DP0_IMAGIC(_L("CImagicContainerBrowser::OpenGLInit++")); + + // Open GL hasn't been initialized + iOpenGlInitialized = EFalse; + + // Describes the format, type and size of the color buffers and + // ancillary buffers for EGLSurface + EGLConfig config; + + // Get the display for drawing graphics + iEglDisplay = eglGetDisplay( EGL_DEFAULT_DISPLAY ); + if ( iEglDisplay == NULL ) + { + DP1_IMAGIC(_L("CImagicContainerBrowser::ConstructL - eglGetDisplay failed - GL Error: %d"),glGetError()); + _LIT(KGetDisplayFailed, "eglGetDisplay failed"); + User::Panic( KGetDisplayFailed, 0 ); + } + + // Initialize display + if ( eglInitialize( iEglDisplay, NULL, NULL ) == EGL_FALSE ) + { + DP1_IMAGIC(_L("CImagicContainerBrowser::ConstructL - eglInitialize failed - GL Error: %d"),glGetError()); + _LIT(KInitializeFailed, "eglInitialize failed"); + User::Panic( KInitializeFailed, 0 ); + } + + // Pointer for EGLConfigs + EGLConfig *configList = NULL; + EGLint numOfConfigs = 0; + EGLint configSize = 0; + + // Get the number of possible EGLConfigs + if ( eglGetConfigs( iEglDisplay, configList, configSize, &numOfConfigs ) == EGL_FALSE ) + { + DP1_IMAGIC(_L("CImagicContainerBrowser::ConstructL - eglGetConfigs failed - GL Error: %d"),glGetError()); + _LIT(KGetConfigsFailed, "eglGetConfigs failed"); + User::Panic( KGetConfigsFailed, 0 ); + } + + configSize = numOfConfigs; + + // Allocate memory for the configList + configList = (EGLConfig*) User::Alloc( sizeof(EGLConfig)*configSize ); + if ( configList == NULL ) + { + DP1_IMAGIC(_L("CImagicContainerBrowser::ConstructL - config alloc failed - GL Error: %d"),glGetError()); + _LIT(KConfigAllocFailed, "config alloc failed"); + User::Panic( KConfigAllocFailed, 0 ); + } + + // Define properties for the wanted EGLSurface. To get the best possible + // performance, choose an EGLConfig with a buffersize matching the current + // window's display mode + TDisplayMode DMode = Window().DisplayMode(); + TInt BufferSize = 0; + + switch(DMode) + { + case(EColor4K): + BufferSize = 12; + break; + case(EColor64K): + BufferSize = 16; + break; + case(EColor16M): + BufferSize = 24; + break; + case(EColor16MU): + case(EColor16MA): + BufferSize = 32; + break; + default: + DP1_IMAGIC(_L("CImagicContainerBrowser::ConstructL - unsupported displaymode - GL Error: %d"),glGetError()); + _LIT(KDModeError, "unsupported displaymode"); + User::Panic( KDModeError, 0 ); + break; + } + + // Define properties for the wanted EGLSurface + const EGLint attrib_list[] = + { + EGL_SURFACE_TYPE, EGL_WINDOW_BIT, + EGL_BUFFER_SIZE, BufferSize, + EGL_DEPTH_SIZE, 16, + EGL_NONE + }; + + + // No configs with antialising were found. Try to get the non-antialiased config + if ( eglChooseConfig( iEglDisplay, attrib_list, configList, configSize, &numOfConfigs ) == EGL_FALSE ) + { + DP1_IMAGIC(_L("CImagicContainerBrowser::ConstructL - eglChooseConfig failed - GL Error: %d"),glGetError()); + _LIT( KChooseConfigFailed, "eglChooseConfig failed" ); + User::Panic( KChooseConfigFailed, 0 ); + } + + if ( numOfConfigs == 0 ) + { + DP1_IMAGIC(_L("CImagicContainerBrowser::ConstructL - Can't find the requested config. - GL Error: %d"),glGetError()); + // No configs found without antialiasing + _LIT( KNoConfig, "Can't find the requested config." ); + User::Panic( KNoConfig, 0 ); + } + + // Choose the best EGLConfig. EGLConfigs returned by eglChooseConfig are + // sorted so that the best matching EGLConfig is first in the list. + config = configList[0]; + + // Free configList, as it's not used anymore. + User::Free( configList ); + + // Create a window where the graphics are blitted + iEglSurface = eglCreateWindowSurface( iEglDisplay, config, &Window(), NULL ); + if ( iEglSurface == NULL ) + { + DP1_IMAGIC(_L("CImagicContainerBrowser::ConstructL - eglCreateWindowSurface failed - GL Error: %d"),glGetError()); + _LIT(KCreateWindowSurfaceFailed, "eglCreateWindowSurface failed"); + User::Panic( KCreateWindowSurfaceFailed, 0 ); + } + + // Create a rendering context + iEglContext = eglCreateContext( iEglDisplay, config, EGL_NO_CONTEXT, NULL ); + if ( iEglContext == NULL ) + { + DP1_IMAGIC(_L("CImagicContainerBrowser::ConstructL - eglCreateContext failed - GL Error: %d"),glGetError()); + _LIT(KCreateContextFailed, "eglCreateContext failed"); + User::Panic( KCreateContextFailed, 0 ); + } + + // Make the context current. Binds context to the current rendering thread + // and surface. + if ( eglMakeCurrent( iEglDisplay, iEglSurface, iEglSurface, iEglContext ) == EGL_FALSE ) + { + DP1_IMAGIC(_L("CImagicContainerBrowser::ConstructL - eglMakeCurrent failed - GL Error: %d"),glGetError()); + _LIT(KMakeCurrentFailed, "eglMakeCurrent failed"); + User::Panic( KMakeCurrentFailed, 0 ); + } + +#ifdef SHADOW_PHOTOS + glClearColor(1,1,1, 0); +#else + glClearColor(0,0,0, 0); +#endif + //glClearDepth(1.0f); // Depth Buffer Setup + glEnable(GL_DEPTH_TEST); // Enables Depth Testing + //glDisable(GL_DEPTH_TEST); // Enables Depth Testing + //glDepthMask(GL_FALSE); + glDepthFunc(GL_LEQUAL); // The Type Of Depth Testing To Do + // TODO, check the perf gain + //glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Really Nice Perspective Calculations + glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST); // Fast Perspective Calculations + glShadeModel(GL_FLAT);//GL_FLAT ,GL_SMOOTH TODO, check perf if smooth is on + //glShadeModel(GL_SMOOTH);//GL_FLAT ,GL_SMOOTH TODO, check perf if smooth is on + //glDisable( GL_LINE_SMOOTH ); + //glEnable with the arguments GL_LINE_SMOOTH or GL_POINT_SMOOTH. + //glEnable(GL_POLYGON_SMOOTH); + //glEnable(GL_POINT_SMOOTH); + //glEnable( GL_LINE_SMOOTH ); + //glEnable(GL_MULTISAMPLE_ARB); + glEnable( GL_TEXTURE_2D ); + glDisable( GL_LIGHTING );//disable for performance reasons + //Disable alpha blending + glDisable(GL_BLEND); + glDisable(GL_ALPHA_TEST); + + + //GLint params; + glGetIntegerv( GL_MAX_TEXTURE_SIZE, &iGLMaxRes ); + DP1_IMAGIC(_L("CImagicContainerBrowser::OpenGLInit - OpenGL max image Res size: %d"), iGLMaxRes); + + glMatrixMode( GL_MODELVIEW ); + + + iOpenGlInitialized = ETrue; + + //Start draw timer + DP0_IMAGIC(_L("CImagicContainerBrowser::OpenGLInit - Start Draw timer")); + iPeriodic->Start( 100, KDisplayDrawFreq, TCallBack( CImagicContainerBrowser::DrawCallBackL, this ) ); + + DP0_IMAGIC(_L("CImagicContainerBrowser::OpenGLInit--")); + } + +//This is called when we want to reduce screen drawing +TInt CImagicContainerBrowser::PowerSaveCallBack(TAny *aInstance) + { + DP0_IMAGIC(_L("CImagicContainerBrowser::PowerSaveCallBack++")); + + ((CImagicContainerBrowser*) aInstance)->PowerSave(); + + DP0_IMAGIC(_L("CImagicContainerBrowser::PowerSaveCallBack--")); + return 0; + } + + +void CImagicContainerBrowser::PowerSave() + { + iPowerSavePeriodic->Cancel(); + + if(iDisplayDrawFreq == KDisplayDrawFreq) + { +#ifndef ADAPTIVE_FRAMERATE + iDisplayDrawFreq = KPowerSaveDisplayDrawFreq; + DisableDisplayDraw(); + if(iImagicAppUi->IsAppOnTop()) + EnableDisplayDraw(); +#endif + } + } + +TInt CImagicContainerBrowser::DisableDrawTimer( TAny* aInstance ) + { + DP0_IMAGIC(_L("CImagicContainerBrowser::DisableDrawTimer++")); + + // Get pointer to instance + CImagicContainerBrowser* instance = (CImagicContainerBrowser*) aInstance; + //instance->iPeriodicTimerActive = EFalse; + instance->DisableDisplayDraw(); + + DP0_IMAGIC(_L("CImagicContainerBrowser::DisableDrawTimer--")); + return 0; + } + +/*----------------------------------------------------------------------*/ +// Destructor +CImagicContainerBrowser::~CImagicContainerBrowser() + { + DP0_IMAGIC(_L("CImagicContainerBrowser::~CImagicContainerBrowser++")); + + //delete iPeriodic; + if(iPeriodic) + { + if(iPeriodic->IsActive()) + iPeriodic->Cancel(); + + delete iPeriodic; + iPeriodic = NULL; + } + + delete iDrawUtility; + + //Cancelling CTimer... + if(iPowerSavePeriodic) + { + if(iPowerSavePeriodic->IsActive()) + iPowerSavePeriodic->Cancel(); + + delete iPowerSavePeriodic; + iPowerSavePeriodic = NULL; + } + + DeleteTextures(); + iDrawLock.Close(); + + if(iTextureLoader) + { + delete iTextureLoader; + iTextureLoader = NULL; + } + + //iFloatCoordinates.Close(); + +#ifdef USE_AVKON_LONGTAP_DETECTOR + if(iLongTapDetector) + { + delete iLongTapDetector; + iLongTapDetector = NULL; + } +#endif + + if(iGesture) + { + delete iGesture; + iGesture = NULL; + } + + //Destruct all engine components + iImagicAppUi->DestructEngine(); + + delete iDrawGrid; + delete iDrawOneByOne; + delete iDrawFaceBrowsing; + + DP0_IMAGIC(_L("CImagicContainerBrowser::~CImagicContainerBrowser--")); + } + +/*----------------------------------------------------------------------*/ +// CTextureManager::DeleteTextures +// Deletes named textures by calling glDeleteTextures. +// +void CImagicContainerBrowser::DeleteTextures() + { + DP0_IMAGIC(_L("CImagicContainerBrowser::DeleteTextures++")); + + iIEngine->CancelFullSizeLoading(); + + if(iPeriodic && iPeriodic->IsActive()) + iPeriodic->Cancel(); + + eglMakeCurrent( iEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT ); + eglDestroySurface( iEglDisplay, iEglSurface ); + eglDestroyContext( iEglDisplay, iEglContext ); + eglTerminate( iEglDisplay ); + + //Delete OpenGL memory allocations + TInt num = iIEngine->GetTotalNumOfImages(); + for(TInt i=0; i < num; i++ ) + { + CImageData* data = iIEngine->GetImageData(i); + + if(data->iGridData.iGlLQ128TextIndex) + glDeleteTextures( 1, &data->iGridData.iGlLQ128TextIndex ); + if(data->iGridData.iGlLQ32TextIndex) + glDeleteTextures( 1, &data->iGridData.iGlLQ32TextIndex ); + if(data->iGridData.iGlHQ512TextIndex != 0) + glDeleteTextures(1, &data->iGridData.iGlHQ512TextIndex); + if(data->iGridData.iGlSuperHQTextIndex != 0) + glDeleteTextures(1, &data->iGridData.iGlSuperHQTextIndex); + + data->iGridData.iGlLQ32TextIndex = 0; + data->iGridData.iGlLQ128TextIndex = 0; + data->iGridData.iGlHQ512TextIndex = 0; + data->iGridData.iGlSuperHQTextIndex = 0; + } + + iOpenGlInitialized = EFalse; + + DP0_IMAGIC(_L("CImagicContainerBrowser::DeleteTextures--")); + } + +/* +//Prepares container to filename array swap +void CImagicContainerBrowser::SwapArrays() + { + DP0_IMAGIC(_L("CImagicContainerBrowser::SwapArrays++")); + + //Delete OpenGL memory allocations + TInt num = iIEngine->GetTotalNumOfImages(); + for(TInt i=0; i < num; i++ ) + { + CImageData* data = iIEngine->GetImageData(i); + + if(data->iGridData.iGlLQ128TextIndex) + glDeleteTextures( 1, &data->iGridData.iGlLQ128TextIndex ); + if(data->iGridData.iGlLQ32TextIndex) + glDeleteTextures( 1, &data->iGridData.iGlLQ32TextIndex ); + if(data->iGridData.iGlHQ512TextIndex != 0) + glDeleteTextures(1, &data->iGridData.iGlHQ512TextIndex); + if(data->iGridData.iGlSuperHQTextIndex != 0) + glDeleteTextures(1, &data->iGridData.iGlSuperHQTextIndex); + + data->iGridData.iGlLQ32TextIndex = 0; + data->iGridData.iGlLQ128TextIndex = 0; + data->iGridData.iGlHQ512TextIndex = 0; + data->iGridData.iGlSuperHQTextIndex = 0; + } + + iOpenGlInitialized = EFalse; + + DP0_IMAGIC(_L("CImagicContainerBrowser::SwapArrays--")); + } +*/ + +void CImagicContainerBrowser::InitFaceBrowsing() + { + iDrawFaceBrowsing->InitFaceBrowsing(); + } + + +/*----------------------------------------------------------------------*/ +// Interpolates given value into target value with step +// +void CImagicContainerBrowser::Interpolate(float &aValue, const float aTarget, const float aStep) + { + //DP0_IMAGIC(_L("CImagicContainerBrowser::Interpolate")); + // Calculate new value + float diff = aTarget-aValue; +// aValue += diff * aStep * iTimeDiff * 30; + float timediff = Min(0.1f, iTimeDiff); // so max value of timediff is 100tick (100ms) + aValue += diff * aStep * timediff * 30; + + // Check that value is in range + if (aValue > aTarget && diff > 0) + aValue = aTarget; + if (aValue < aTarget && diff < 0) + aValue = aTarget; + } + +/*----------------------------------------------------------------------*/ +// Makes sure that given value is within limits +// +void CImagicContainerBrowser::CheckLimits(float &aValue, const float aMin, const float aMax) + { + DP0_IMAGIC(_L("CImagicContainerBrowser::CheckLimits")); + if (aValue < aMin) + aValue = aMin; + if (aValue > aMax) + aValue = aMax; + } + +/*----------------------------------------------------------------------*/ +// Handle rotation keys +// +void CImagicContainerBrowser::HandleRotationKeys(void) + { + //DP0_IMAGIC(_L("CImagicContainerBrowser::HandleRotationKeys")); + // Handle rotation + CImageData* imageData = iIEngine->GetImageData(iCurrentIndex); + if(imageData) + imageData->iGridData.iTargetRotationAngle += iKeyData.iRotate*90; + iKeyData.iRotate = 0; + } + + +TInt CImagicContainerBrowser::GetFreeRam() + { + TInt mem = 0; + TInt ret = HAL::Get(HALData::EMemoryRAMFree, mem); + DP1_IMAGIC(_L("CImagicContainerBrowser::CheckFreeRam - mem: %d"),mem); + return mem; + } + + + +/*----------------------------------------------------------------------*/ +// Checks limits for iFileIndex and starts loading image when +// new image was selected +// +void CImagicContainerBrowser::DynamicLoadingL() + { + if(!iDynamicLoadingOn && !iNewImageAdded) + { + DP2_IMAGIC(_L("CImagicContainerBrowser::DynamicLoadingL - return #Loading is off, iDynamicLoadingOn:%d, iNewImageAdded:%d"),iDynamicLoadingOn,iNewImageAdded); + return; + } + + // Check that loader is not running + if(iTextureLoader->IsRunning()) + { + DP0_IMAGIC(_L("CImagicContainerBrowser::DynamicLoadingL - return #Loader is running")); + +/* if(iIsLoaderRunning > 30) + { + DP0_IMAGIC(_L("CImagicContainerBrowser::DynamicLoadingL - return #Loader is running >30 times in loop")); + iIsLoaderRunning = 0; + iDynamicLoadingOn = EFalse; + iNewImageAdded = EFalse; + } + + iIsLoaderRunning++;*/ + + return; + } + + if(iPreferHighResLoading) + { + DP0_IMAGIC(_L("CImagicContainerBrowser::DynamicLoadingL - return #Prefer High res loading")); + return; + } + + DP0_IMAGIC(_L("CImagicContainerBrowser::DynamicLoadingL++")); + + /*TInt imageBuffer = iIEngine->IsScanningFiles() ? + K128TNImageBuffer + KNumOf32ThumbsLoadedBefore128Thumb : + K32TNImageBuffer;*/ + + TInt imageBuffer = K32TNImageBuffer; + + //DP0_IMAGIC(_L("CImagicContainerBrowser::DynamicLoadingL load closest unloaded image")); + + for (TInt i = 0;i < imageBuffer; i++) + { + // Check to positive and negative direction from current picture + for (TInt j = 0; j < 2; j++) + { + // Calculate image index + TInt index = iCurrentIndex + (j ? i : -i); + + // Check that index is valid + if (index >= 0 && index < iIEngine->GetTotalNumOfImages()) + { + CImageData* imageData = iIEngine->GetImageData(index); + // Load tiny thumbnail + if( !imageData->iGridData.iCorrupted && + imageData->iGridData.iGlLQ32TextIndex == 0 && + (imageData->IsImageReady(ESize32x32) || + imageData->IsImageReady(EExifThumb)) //&& + //Abs(iCurrentIndex-index) <= K32TNImageBuffer + ) + { + TRAPD(err, iTextureLoader->LoadL(imageData, ESize32x32)); + if(err == KErrNone) + { + DP0_IMAGIC(_L("CImagicContainerBrowser::DynamicLoadingL - start loading 32x32")); + i = imageBuffer + 1; + iNewImageAdded = EFalse;//should be set off only when we tried to load new image + break; //Image loading did start, break out + } + } + } + + // Load higher resolution thumb only after couple of tiny thumbs + TInt i2 = i - KNumOf32ThumbsLoadedBefore128Thumb; + if (i2 < 0) + continue; + + // Calculate image index + index = iCurrentIndex + (j ? i2 : -i2); + + // Check that index is valid + if (index < 0 || index >= iIEngine->GetTotalNumOfImages()) + continue; + + CImageData* imageData = iIEngine->GetImageData(index); + // Higher resolution thumbnail exist + if(!imageData->iGridData.iCorrupted && + imageData->iGridData.iGlLQ128TextIndex == 0 && + (imageData->IsImageReady(ESize128x128) || + imageData->IsImageReady(EExifThumb)) && + Abs(iCurrentIndex-index) <= K128TNImageBuffer) + { + //Do not load 128 TN before tilted to flat + if(IsHwAcceleration() && Abs(iDrawGrid->GetCurrentGridTilt()) < KAngle2Start128LoadingHwAcc) + { + TRAPD(err, iTextureLoader->LoadL(imageData, ESize128x128)); + if(err == KErrNone) + { + DP0_IMAGIC(_L("CImagicContainerBrowser::DynamicLoadingL - start loading 128x128")); + i = imageBuffer + 1; + iNewImageAdded = EFalse;//should be set off only when we tried to load new image + break; //Image loading did start, break out + } + } + if(!IsHwAcceleration() && Abs(iDrawGrid->GetCurrentGridTilt()) < KAngle2Start128Loading) + { + TRAPD(err, iTextureLoader->LoadL(imageData, ESize128x128)); + if(err == KErrNone) + { + DP0_IMAGIC(_L("CImagicContainerBrowser::DynamicLoadingL - start loading 128x128")); + i = imageBuffer + 1; + iNewImageAdded = EFalse;//should be set off only when we tried to load new image + break; //Image loading did start, break out + } + } + } + } + } + + iNewImageAdded = EFalse; + + // Wait until something new happen before continue loading + iDynamicLoadingOn = iIEngine->IsScanningFiles(); + + DP0_IMAGIC(_L("CImagicContainerBrowser::DynamicLoadingL--")); + } + +void CImagicContainerBrowser::NewImageAdded() + { + iNewImageAdded = ETrue; + } + +void CImagicContainerBrowser::ImageListChanged(TInt aIndex, TBool aAdded) + { + if (iDrawGrid) + iDrawGrid->UpdateImageCoordinates(aIndex); + + if (IsUserInputGiven()) + { + /* TODO if (iCurrentIndex >= aIndex) + { + if (aAdded) + iCurrentIndex++; + else + iCurrentIndex--; + CheckIndexLimits(iCurrentIndex); + }*/ + } + iDynamicLoadingOn = ETrue; + } + +/*----------------------------------------------------------------------*/ +// Unloads images from Grid +// +void CImagicContainerBrowser::DynamicUnLoading() + { + DP0_IMAGIC(_L("CImagicContainerBrowser::DynamicUnLoading++")); + + CImageData* imageData = NULL; + + // Loop through all pictures + for (TInt i=0; iGetTotalNumOfImages(); i++) + { + // Check if picture is loaded + imageData = iIEngine->GetImageData(i); + + if(imageData->iGridData.iGlLQ32TextIndex!=0) + if(i<(iCurrentIndex-(K32TNImageUnLoadBuffer+1)) || i>(iCurrentIndex+(K32TNImageUnLoadBuffer+1))) + { + // Unload picture + iTextureLoader->UnloadLQ32Tex( imageData ); + DP1_IMAGIC(_L("CImagicContainerBrowser::DynamicUnLoading - Unload 32x32 [%d] texture!!!!!"),i); + } + if(imageData->iGridData.iGlLQ128TextIndex != 0) + if(i<(iCurrentIndex-(K128TNImageBuffer+1)) || i>(iCurrentIndex+(K128TNImageBuffer+1))) + { + // Unload picture + iTextureLoader->UnloadLQ128Tex( imageData ); + DP1_IMAGIC(_L("CImagicContainerBrowser::DynamicUnLoading - Unload 128x128 [%d] texture!!!!!"),i); + } + if(imageData->iGridData.iGlHQ512TextIndex != 0 ) + if((i < (iCurrentIndex-(K512TNImageBuffer+1))) || (i > (iCurrentIndex+(K512TNImageBuffer+1)))) + { + //Unload picture + iTextureLoader->UnloadLQ512Tex( imageData ); + DP1_IMAGIC(_L("CImagicContainerBrowser::DynamicUnLoading - Unload 512x512 [%d] texture!!!!!"),i); + } + + if(imageData->iGridData.iGlSuperHQTextIndex != 0) + if(i != iCurrentIndex) + { + //Unload picture + iTextureLoader->ReleaseSuperHResTexture( imageData ); + DP1_IMAGIC(_L("CImagicContainerBrowser::DynamicUnLoading - Unload Superresolution [%d] texture!!!!!"),i); + } + } + + DP0_IMAGIC(_L("CImagicContainerBrowser::DynamicUnLoading--")); + } + + +/*----------------------------------------------------------------------*/ +// Calculates widht and height with aspect ratio +// +#if 0 +void CImagicContainerBrowser::BubbleEffect(TInt& x, TInt& y, float& z) + { + if(iBubbleEffect) + { + // Selected image in coordinates x,y + iSelectedX = iCurrentIndex/iGridSizeY; + iSelectedY =- (iCurrentIndex%iGridSizeY); + + // Distance to selected + iDistanceX = iSelectedX-x; + iDistanceY = iSelectedY-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=4.2; + if (iDiff==1) z=3.973029769; + if (iDiff==2) z=3.363097092; + if (iDiff==3) z=2.547428771; + if (iDiff==4) z=1.72667162; + if (iDiff==5) z=1.047279277; + if (iDiff==6) z=0.56840819; + if (iDiff==7) z=0.27605982; + if (iDiff==8) z=0.119975103; + if (iDiff==9) z=0.046657785; + if (iDiff==10) z=0.016236865; + if (iDiff>10) z=0; + */ + 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; + } + } +#endif + +/*----------------------------------------------------------------------*/ +// Calculates widht and height with aspect ratio +// +void CImagicContainerBrowser::CalculateImageSize(float& aWidth, float& aHeight, const float aAspectRatio/*display aspectratio*/) + { + DP0_IMAGIC(_L("CImagicContainerBrowser::CalculateImageSize")); + // Check picture orientation + TBool landscape = EFalse; + TBool tmp = EFalse; + CImageData* imageData = iIEngine->GetImageData(iCurrentIndex); + + if(imageData->GetAspectRatio() > 1) + landscape = ETrue; + + //Change landscape<->portrait if pic is rotated 90 or 270 + //if(imageData->iGridData.iTargetRotationAngle%90==0 && imageData->iGridData.iTargetRotationAngle%180!=0) + //if(Abs(imageData->iGridData.iTargetRotationAngle-90) <= 0.1 && Abs(imageData->iGridData.iTargetRotationAngle-270) <= 0.1) + TInt angle = imageData->iGridData.iTargetRotationAngle; + if(angle % 90 == 0 && angle % 180 != 0) + { + tmp=ETrue; + landscape = !landscape; + } + + //Calculate new width and height + aWidth=0.5; + aHeight=0.5; + + if(landscape) + { + //Fix aspect ratio + aHeight/=aAspectRatio; + if(imageData->GetAspectRatio() < aAspectRatio && imageData->GetAspectRatio() >= 1) + { + aHeight = aHeight * (aAspectRatio/imageData->GetAspectRatio()); + aWidth = aWidth * (aAspectRatio/imageData->GetAspectRatio()); + } + //If portrait picture aspect ratio is between 0.75 - 1 + if(imageData->GetAspectRatio() > (1.0 / aAspectRatio) && imageData->GetAspectRatio() < 1) + { + aHeight = aHeight * (aAspectRatio*imageData->GetAspectRatio()); + aWidth = aWidth * (aAspectRatio*imageData->GetAspectRatio()); + } + } + else + { + //Fix aspect ratio + aWidth *= aAspectRatio; + } +} + + + +/*----------------------------------------------------------------------*/ +// Draws one by one view +// +void CImagicContainerBrowser::GetCurrentFilenameL(TFileName& aFilename, TThumbSize aRes) + { + iIEngine->GetFileNameL(iCurrentIndex, aRes, aFilename); + } + +void CImagicContainerBrowser::SetCurrentFaceNro(TInt aNro) + { + iDrawFaceBrowsing->SetCurrentFaceNro(aNro); + } + +#if 0 +/*----------------------------------------------------------------------*/ +// Gets current screen coords +// +void CImagicContainerBrowser::ConvertScreenCoords2QvgaCoords(TPoint& aPoint, TRect& aRect) + { + CImageData* imageData = iIEngine->GetImageData(iCurrentIndex); + + TInt pictureWidth, pictureHeigth; + pictureWidth=320; + pictureHeigth=320; + + //Calculate coords from alogorith to OpenGL -0.5 - +0.5 coords and fill the array + float tmpX; + float tmpY; + if(imageData->GetAspectRatio() > 1) + { + //Convert from center of screen to corner coords + tmpX = iDrawOneByOne->GetDrawOneByOneXY().iX + 0.5; + tmpY = iDrawOneByOne->GetDrawOneByOneXY().iY + (0.5/imageData->GetAspectRatio()); + } + else//portrait + { + //Convert from center of screen to corner coords + tmpX = iDrawOneByOne->GetDrawOneByOneXY().iX + (0.5*imageData->GetAspectRatio()); + tmpY = iDrawOneByOne->GetDrawOneByOneXY().iY + 0.5; + } + + aPoint.iX = tmpX * pictureWidth; + aPoint.iY = tmpY * pictureHeigth; + + TInt rectWidth = pictureWidth; + TInt rectHeigth = pictureHeigth; + + rectWidth = rectWidth/(iDrawOneByOne->GetDrawOneByOneZoom()*2); + rectHeigth = rectHeigth/(iDrawOneByOne->GetDrawOneByOneZoom()*2); + + aRect.iTl.iX = aPoint.iX-(rectWidth/2); + aRect.iTl.iY = aPoint.iY-(rectHeigth/2); + aRect.iBr.iX = aPoint.iX+(rectWidth/2); + aRect.iBr.iY = aPoint.iY+(rectHeigth/2); + + } +#endif + +void CImagicContainerBrowser::LoadHighResImage(CImageData* imageData, TInt aIndex) + { + DP0_IMAGIC(_L("CImagicContainerBrowser::LoadHighResImage++")); + + //Make sure that 512 for current image is loaded + if(imageData->iGridData.iGlHQ512TextIndex == 0) + { + LoadHQ512Image(imageData, aIndex); + return; + } + +#ifdef SUPERZOOM + //Load "super zoom" image if in zoom or face browser + if(imageData->iGridData.iGlSuperHQTextIndex == 0 && + (!IS_NOT_IN_ZOOM_ONEBYONE || iDrawOneByOne->IsMagGlassOn() )) + { + //iPreferHighResLoading = ETrue; + TRAPD(err, iTextureLoader->LoadL(imageData, EFullSize)); + if( err == KErrNone || err == KErrInUse ) + iPreferHighResLoading = ETrue; + + /*if(err != KErrNone) + if(err == KErrAlreadyExists || err == KErrInUse) + iPreferHighResLoading = ETrue; + else + iPreferHighResLoading = EFalse;*/ + } +#endif + + CImageData* imageDataLoad = NULL; + //Here we load 512x512 resolution images, one to both sides of current up to limit + for (TInt i = 1; i <= K512TNImageBuffer; i++) + { + // Check to positive and negative direction from current picture + for (TInt j = 0; j < 2; j++) + { + // Calculate image index + TInt index = iCurrentIndex + (j ? i : -i); + + if(index >= 0 && index < iIEngine->GetTotalNumOfImages()) + { + imageDataLoad = iIEngine->GetImageData(index); + if(imageDataLoad == NULL) + break; + + if(imageDataLoad->iGridData.iGlHQ512TextIndex == 0) + { + DP1_IMAGIC(_L("CImagicContainerBrowser::LoadHighResImage -------------- Start High res image loading, index: %d"), index); + LoadHQ512Image(imageDataLoad, index); + return; + } + + } + } + } + + + DP0_IMAGIC(_L("CImagicContainerBrowser::LoadHighResImage--")); + } + + +void CImagicContainerBrowser::LoadHQ512Image(CImageData* imageData, TInt aIndex) + { + DP0_IMAGIC(_L("CImagicContainerBrowser::LoadHQ512Image++")); + + //iPreferHighResLoading = ETrue; + + if(/*iDrawOneByOne->GetDrawOneByOneZoom() > 0.99 &&*/ imageData) + { + TInt error; + if((imageData->iGridData.iGlLQ128TextIndex == 0) && (iCurrentIndex == aIndex)) + TRAPD(error, iTextureLoader->LoadL(imageData, ESize128x128)); + + if(imageData->iGridData.iGlHQ512TextIndex == 0) + { + //iPreferHighResLoading = ETrue; + TRAPD(err, iTextureLoader->LoadL(imageData, ESize512x512)); +/* if(err != KErrNone) + if(err == KErrAlreadyExists || err == KErrInUse) + iPreferHighResLoading = ETrue; + else + iPreferHighResLoading = EFalse;*/ + + if( err == KErrNone || err == KErrInUse ) + { + DP0_IMAGIC(_L("CImagicContainerBrowser::LoadHQ512Image - set dyn loading off")); + iPreferHighResLoading = ETrue; + iDynamicLoadingOn = EFalse; //set to false to be able to get run time for high res loading + } + else if(err == KErrAlreadyExists) + { + DP0_IMAGIC(_L("CImagicContainerBrowser::LoadHQ512Image - set dyn loading on")); + iDynamicLoadingOn = ETrue; + } + } + + } + + DP0_IMAGIC(_L("CImagicContainerBrowser::LoadHQ512Image--")); + } + + +void CImagicContainerBrowser::ShowMagGlass(const TBool aState) + { + // do nothing if it's already in the state + if (/*iMagGlassOn*/ iDrawOneByOne->IsMagGlassOn() == aState || !IS_NOT_IN_ZOOM_ONEBYONE) + return; + + iDrawOneByOne->SetMagGlassPrevStatus(iDrawOneByOne->IsMagGlassOn()); + iDrawOneByOne->SetMagGlassStatus(aState); + } + + + +void CImagicContainerBrowser::SetMinMagFilterLinear(TBool aValue) + { + if(iDrawFunction == EOneByOne || iDrawFunction == EFaceBrowsing) + if(IsHwAcceleration()) + iMinMagFilterSetting=ETrue; + else + iMinMagFilterSetting=aValue; + else + iMinMagFilterSetting=aValue; + } + +TBool CImagicContainerBrowser::IsHwAcceleration() + { + return (iGLMaxRes == 2048)? ETrue: EFalse; + } + +void CImagicContainerBrowser::SetMinMagFilterLinearDo(TBool aValue) + { + DP0_IMAGIC(_L("CImagicContainerBrowser::SetMinMagFilterLinear++")); + + CImageData* imageData = iIEngine->GetImageData(iCurrentIndex); + + if(iCurrentBindedIndex == imageData->iGridData.iGlLQ128TextIndex || + iCurrentBindedIndex == imageData->iGridData.iGlLQ32TextIndex) + { + DP0_IMAGIC(_L("CImagicContainerBrowser::SetMagFilterLinear - Linear")); + iMagFilterLinear = ETrue; + glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + } + else if(aValue) + { + DP0_IMAGIC(_L("CImagicContainerBrowser::SetMagFilterLinear - Linear")); + iMagFilterLinear = ETrue; + glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + } + else + { + DP0_IMAGIC(_L("CImagicContainerBrowser::SetMagFilterLinear - Nearest")); + iMagFilterLinear = EFalse; + glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + } + + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); + + + DP0_IMAGIC(_L("CImagicContainerBrowser::SetMinMagFilterLinear--")); + } + +void CImagicContainerBrowser::DrawFaceBrowsingIcon() + { +#ifdef ICONS_ENABLAD + if((!iMagGlassOn && iDrawFunction==EFaceBrowser) || + (iDrawFunction==EFaceBrowser) && (iIconTextureIndexes.Count() >= 1)) + { + iDrawUtility->DrawIcon(Size(), iIconTextureIndexes[0]); + SetMinMagFilterLinearDo(ETrue); + } +#endif + } + +void CImagicContainerBrowser::DrawZoomIcon() + { +#ifdef ICONS_ENABLAD + if((!iMagGlassOn && iDrawFunction==EOneByOne && (iDrawOneByOneZoom-1.0) > 0.01) && + (iIconTextureIndexes.Count()>=2)) + { + iDrawUtility->DrawIcon(Size(), iIconTextureIndexes[1]); + SetMinMagFilterLinearDo(ETrue); + } +#endif + } + +void CImagicContainerBrowser::SetDeleteTextures(TBool aValue) + { + DeleteTextures(); + iDeleteTextures = aValue; + } + + + +//--------------------------------------------------------------------------------- +//DrawCallBack for OpenGL +TInt CImagicContainerBrowser::DrawCallBackL( TAny* aInstance ) + { + //DP0_IMAGIC(_L("CImagicContainerBrowser::DrawCallBack")); + // Get pointer to instance + ((CImagicContainerBrowser*) aInstance)->DrawL(); + return 0; + } + +void CImagicContainerBrowser::DrawL() + { +#ifdef ADAPTIVE_FRAMERATE + // No drawing if timer is not zero + if (iWaitDrawTicks != 0) + { + if (iWaitDrawTicks > 0) + iWaitDrawTicks--; + return; + } + + iWaitDrawTicks = -1; + + //TInt startTick = +#endif + + + + if(iDeleteTextures) + { + if(iPeriodic->IsActive()) + iPeriodic->Cancel(); + DeleteTextures(); + + return; + } + + + TSize size = Size(); + BeginDrawing(); + + + + if(!iScreenRotateOngoing) + { + + // Call proper draw function + switch (iDrawFunction) + { + case EGrid: + + if(iIEngine->IsScanningFiles()) + { + if(iDrawOnes == 0) + iDrawOnes = 1;//make sure we draw screen ones when start application + } +#if 0 + if(iDynamicLoadingOn) + { + DP0_IMAGIC(_L("CImagicContainerBrowser::DrawCallBack - Continue Image Loading")); + DynamicLoadingL(); + } + +#endif + + if(iDrawGrid->IsDrawingNeededGrid() || iDrawOnes == 1) + { + drawZoom = 1; inPictureX = 0; inPictureY = 0; + iDrawGrid->DrawGridL(size); + EndDrawing(); + if(iIEngine->GetTotalNumOfImages() > 0) + iDrawOnes = -1; + } + + break; + + case EOneByOne: + if(iDrawOneByOne->IsDrawingNeededOneByOne()) + { + iDrawOneByOne->DrawOnebyOneL(size); + EndDrawing(); + } + break; + + case EFaceBrowser: + if(iDrawFaceBrowsing->IsDrawingNeededFaceBrowsing()) + { + iDrawFaceBrowsing->DrawFaceBrowsing(size); + drawZoom = 1; inPictureX = 0; inPictureY = 0; + iDrawFaceBrowsing->GetFBZoomAndLocation(drawZoom, inPictureX, inPictureY); + EndDrawing(); + } + break; + + default: + // Should never come here + break; + } + } + +#ifdef ADAPTIVE_FRAMERATE + iWaitDrawTicks = KWaitTicksAfterDraw; // wait 20ms +#endif + } + +void CImagicContainerBrowser::BeginDrawing() + { + // Calculate used time between two frames + iTimeNow = User::NTickCount(); + +#ifdef __WINS__ + // In the emulator the tickcount runs at 200Hz + iTimeDiff = (GLfloat)(iTimeNow - iLastTime)/200; + iLastTime = iTimeNow; +#else + // In the HW the tickcount runs at 1000Hz + iTimeDiff = (GLfloat)(iTimeNow - iLastTime)/1000; + iLastTime = iTimeNow; +#endif + + //Prevent screen draw while rotating screen + //if(!iScreenRotateOngoing) + { + // Get window size + //aSize = Size(); + + // Enable client state + glEnableClientState(GL_VERTEX_ARRAY); + glEnableClientState(GL_TEXTURE_COORD_ARRAY); + glTexCoordPointer( 2, GL_FIXED, 0, iGlobalTexCoords ); + } + + } + +void CImagicContainerBrowser::EndDrawing() + { +#ifdef LOADING_ANIMATION + // Handle loading animation + glColor4f(1,1,1,1); + iDrawUtility->Update(); + iDrawUtility->Draw(Size()); + + TBool tmp = iMagFilterLinear; + iMagFilterLinear = ETrue; + + + DrawFaceBrowsingIcon(); + DrawZoomIcon(); + + iMagFilterLinear = tmp; +#endif + + /*iMenuAlpha-=0.05; + if(iMenuAlpha < 0) + iMenuAlpha = 0; + iDrawUtility->DrawIcon2(Size(), iLoadingTextureIndex, iMenuAlpha);*/ + + + //Prevent screen draw while rotating screen + //if(!iScreenRotateOngoing) + { + // Disable client state + glDisableClientState(GL_VERTEX_ARRAY); + glDisableClientState(GL_TEXTURE_COORD_ARRAY); + + + // Call eglSwapBuffers, which blit the graphics to the window + if( !eglSwapBuffers( iEglDisplay, iEglSurface ) ) + { + _LIT(KTextOpenGlError, "ERROR in OpenGL draw: eglSwapBuffers error"); + CAknErrorNote* note = new ( ELeave ) CAknErrorNote(ETrue); + TBuf<256> text; + text.Format(KTextOpenGlError); + note->ExecuteLD( text ); + + //suspend or some other power event occurred, context lost + OpenGLInitL(); /* reinitialize EGL */ + + InitL(); /* reinitialize grid data */ + iDrawFunction = EGrid; + } + + // Check for errors + //EGLint err = eglGetError(); + EGLint err = glGetError(); + //err=EGL_CONTEXT_LOST; + //if(err != EGL_SUCCESS) + TBool init = EFalse; + //while(err != EGL_SUCCESS)GL_NO_ERROR + while(err != GL_NO_ERROR) + { + /*_LIT(KTextOpenGlError, "ERROR in OpenGL draw: %d"); + CAknErrorNote* note = new ( ELeave ) CAknErrorNote(ETrue); + TBuf<256> text; + text.Format(KTextOpenGlError, err); + note->ExecuteLD( text );*/ + + //suspend or some other power event occurred, context lost + /*DeleteTextures(); + OpenGLInitL(); + InitL();*/ + iDrawFunction = EGrid; + err = glGetError(); + init = ETrue; + } + + if(init) + { + DeleteTextures(); + OpenGLInitL(); /* reinitialize EGL */ + InitL(); /* reinitialize grid data */ + } + + // Clear buffers + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + } + } + +// --------------------------------------------------------- +// CImagicContainerBrowser::SizeChanged() +// Called by framework when the view size is changed +// --------------------------------------------------------- +// +void CImagicContainerBrowser::SizeChanged() + { + DP0_IMAGIC(_L("CImagicContainerBrowser::SizeChanged")); + + iScreenRotateOngoing = ETrue; + //TSize size = this->Size(); + iScreenSize = this->Size(); + iScreenAspectRatio = (TReal)iScreenSize.iWidth / (TReal)iScreenSize.iHeight; + + // Reinitialize viewport and projection. + glViewport( 0, 0, iScreenSize.iWidth, iScreenSize.iHeight ); + + if(iScreenSize.iHeight > iScreenSize.iWidth) + {//Portrait + iDisplayRotation = -90; + iDisplayRotationTarget = 0; + } + else + {//Landscape + iDisplayRotation = 90; + } + + iScreenRotateOngoing = EFalse; + + iDrawNow = ETrue; + + } + +float CImagicContainerBrowser::GetDisplayRotTargetAngle() + { + return iDisplayRotationTarget; + } + +float CImagicContainerBrowser::GetDisplayRotAngle() + { + return iDisplayRotation; + } + +void CImagicContainerBrowser::SetDisplayRotAngle(float aValue) + { + iDisplayRotationTarget = aValue; + } + + +// --------------------------------------------------------- +// CImagicContainerBrowser::CountComponentControls() const +// --------------------------------------------------------- +// +TInt CImagicContainerBrowser::CountComponentControls() const + { + return 0; // return nbr of controls inside this container + } + +// --------------------------------------------------------- +// CImagicContainerBrowser::ComponentControl(TInt aIndex) const +// --------------------------------------------------------- +// +CCoeControl* CImagicContainerBrowser::ComponentControl(TInt /*aIndex*/) const + { + + return NULL; + } + +// --------------------------------------------------------- +// CImagicContainerBrowser::Draw(const TRect& aRect) const +// --------------------------------------------------------- +// +void CImagicContainerBrowser::Draw(const TRect& /*aRect*/) const + { + DP0_IMAGIC(_L("CImagicContainerBrowser::Draw")); + + CImagicContainerBrowser* self=const_cast(this); + self->iDrawNow = ETrue; + + /*if(iScreenImmeadetaUpdate) + self->DrawL();*/ + } + +void CImagicContainerBrowser::SetScreenImmeadetaUpdate(TBool aValue) + { + iScreenImmeadetaUpdate = aValue; + } + + +// --------------------------------------------------------- +// CImagicContainerBrowser::HandleControlEventL( +// CCoeControl* aControl,TCoeEvent aEventType) +// --------------------------------------------------------- +// +void CImagicContainerBrowser::HandleControlEventL(CCoeControl* /*aControl*/,TCoeEvent /*aEventType*/) + { + // Add your control event handler code here + } + +// --------------------------------------------------------- +// CImagicContainerBrowser::HandlePointerEventL( +// const TPointerEvent& aPointerEvent) +// --------------------------------------------------------- +// +void CImagicContainerBrowser::HandlePointerEventL(const TPointerEvent& aPointerEvent) + { + DP0_IMAGIC(_L("CImagicContainerBrowser::HandlePointerEventL++")); + + EnableDisplayDraw(); + + //Set normal display draw speed if we were in low draw freq +#ifdef USE_LOW_DRAW_SPEED_WHILE_LOADING + SetDrawFreqToNormal(KPowerSavePeriodicDelay); +#endif + + iUserInputGiven = ETrue; + iLastEventFromKeys = EFalse; + iOnTheEdge=ETrue; + + /* Lets not put this on, othervise does not work in S60 3.2 + // Do nothing if non-touch + if (!AknLayoutUtils::PenEnabled() ) + { + return; + } +*/ + +#ifdef USE_AVKON_LONGTAP_DETECTOR + // Pass the pointer event to Long tap detector component + iLongTapDetector->PointerEventL(aPointerEvent); +#endif + +#ifdef USE_AVKON_TACTILE_FEEDBACK + if (aPointerEvent.iType == TPointerEvent::EButton1Down) + { + // Give feedback to user (vibration) + iTouchFeedBack->InstantFeedback(ETouchFeedbackBasic); + } +#endif + + if ( AknLayoutUtils::PenEnabled() ) + { + iGesture->PointerEventL(aPointerEvent); + } + + // Call base class HandlePointerEventL() + CCoeControl::HandlePointerEventL(aPointerEvent); + + SetLastTouchPoint(aPointerEvent.iPosition); + + DP0_IMAGIC(_L("CImagicContainerBrowser::HandlePointerEventL--")); + } + +void CImagicContainerBrowser::SetLastTouchPoint(const TPoint& aPos) + { + + iTouchPointThreshold = EFalse; + + if(Abs(aPos.iX-iLastTouchPoint.iX) > 2)//TODO, mika: check correct size + { + iTouchPointThreshold = ETrue; + } + if(Abs(aPos.iY-iLastTouchPoint.iY) > 2) + { + iTouchPointThreshold = ETrue; + } + + //Change touch point only if we moved more than 5 pixel + //if(changeTouchPoint) + iLastTouchPoint = aPos; + } + +TBool CImagicContainerBrowser::IsTouchPointThresholdExeed() + { + return iTouchPointThreshold; + } + +TPoint CImagicContainerBrowser::GetLastTouchPoint(void) + { + return iLastTouchPoint; + } + +// --------------------------------------------------------- +// CImagicContainerBrowser::HandleLongTapEventL( +// const TPoint& aPenEventLocation, const TPoint& aPenEventScreenLocation) +// --------------------------------------------------------- +// +void CImagicContainerBrowser::HandleLongTapEventL(const TPoint& /*aPenEventLocation*/, + const TPoint& /*aPenEventScreenLocation*/) + { + DP0_IMAGIC(_L("CImagicContainerBrowser::HandleLongTapEventL++")); + + //THIS FUNCTION IS NOT USED, USE INSTEAD DoLongTap() TO HANDLE LONG TAP EVENTS!!! + + DP0_IMAGIC(_L("CImagicContainerBrowser::HandleLongTapEventL--")); + } + +// --------------------------------------------------------- +// CImagicContainerBrowser::FindImageInScreen( +// const TPoint aPos, TInt& aResultIndex) +// --------------------------------------------------------- +// +TBool CImagicContainerBrowser::FindImageInScreen(const TPoint aPos, TInt& aResultIndex) + { + GLfloat modelview[16]; + glGetFloatv(GL_MODELVIEW_MATRIX, modelview); + + GLfloat projection[16]; + glGetFloatv(GL_PROJECTION_MATRIX, projection); + + int viewport[4]; + glGetIntegerv(GL_VIEWPORT, viewport); + + GLfloat x = aPos.iX; + GLfloat y = this->Size().iHeight - 1 - aPos.iY; + GLfloat objX[2], objY[2], objZ[2]; // [0] for near, [1] for far + + // Get coords in near and far plane. The coords give the ray from near to far plane. + gluUnProject(x,y,0.0,modelview,projection,viewport,&objX[0],&objY[0],&objZ[0]); + gluUnProject(x,y,1.0,modelview,projection,viewport,&objX[1],&objY[1],&objZ[1]); + + DP3_IMAGIC(_L("####### UnProject(z=0, near):X=%6.4f,Y=%6.4f,Z=%6.4f"), objX[0],objY[0],objZ[0]); + DP3_IMAGIC(_L("####### UnProject(z=1.0,far):X=%6.4f,Y=%6.4f,Z=%6.4f"), objX[1],objY[1],objZ[1]); + DP3_IMAGIC(_L("####### Device (%d):x=%6.3f,y=%6.3f,z=not known"), iCurrentIndex, x,y); + DP3_IMAGIC(_L("####### Current(%d):x=%6.4f,y=%6.4f"),iCurrentIndex, (iCurrentIndex / CImagicContainerBrowser::KGridSizeY) * KSpacingX, -(iCurrentIndex % CImagicContainerBrowser::KGridSizeY) * KSpacingY); + + GLfloat perspectiveDepth = objZ[0] - objZ[1]; // near value is bigger. depth = near - far. + + aResultIndex = -1; // gives invalid value if not found + + // The ray is linear. Can get xy at a depth by multiply '(a depth)/(near/far depth)' + TInt numOfImages = iIEngine->GetTotalNumOfImages(); + for (TInt i = 0; i < numOfImages; ++i) + { + GLfloat itemZ = iIEngine->GetImageData(i)->iGridData.iZ; + GLfloat itemDepthCoord = -itemZ - iDrawGrid->GetGridZoom(); // - objZ[0]; // camera shifted by iDrawGridZoom. perspective starts from near. + GLfloat itemDepth = itemDepthCoord / perspectiveDepth; + + GLfloat itemX = objX[0] + itemDepth * (objX[1] - objX[0]); // = near + u(far - near) + GLfloat itemY = objY[0] + itemDepth * (objY[1] - objY[0]); // = near + u(far - near) + + CImageData* imageData = iIEngine->GetImageData(i); + GLfloat itemScale = imageData->iGridData.iScale; + + GLfloat width = KSpacingX; // * itemScale; // TODO: check!. No need to consider scaling. Why? + GLfloat height = KSpacingY; // * itemScale; + GLfloat objx = imageData->iGridData.iX; + GLfloat objy = imageData->iGridData.iY; + //GLfloat objx = (i / CImagicContainerBrowser::KGridSizeY) * width; + //GLfloat objy = -(i % CImagicContainerBrowser::KGridSizeY) * height; + //TODO: consider aspect ratio + + DP3_IMAGIC(_L("####### UnProject: itemX=%f, itemY=%f, itemZ=%f"), itemX, itemY, itemZ); + DP4_IMAGIC(_L("####### UnProject: itemDepthCoord=%f, perspectiveDepth=%f, itemDepth=%f, itemScale=%f"), + itemDepthCoord, perspectiveDepth, itemDepth, itemScale); + DP4_IMAGIC(_L("#######(%d) %6.4f < x(%6.4f) < %6.4f"), i, objx-width/2, itemX, objx+width/2); + DP4_IMAGIC(_L("#######(%d) %6.4f < y(%6.4f) < %6.4f"), i, objy-height/2, itemY, objy+height/2); + + if (objx-width/2 <= itemX && itemX < objx + width/2) + { + if (objy-height/2 <= itemY && itemY < objy + height/2) + { + aResultIndex = i; + break; + } + } + } + +#if 0 + // just trial code. useful for checking unprojection results + z = 0.9997; // best reasonable fixed value from experience + gluUnProject(x,y,z,modelview,projection,viewport,&objX,&objY,&objZ); + RDebug::Print(_L("####### UnProject(z=%8.6f):X=%6.4f,Y=%6.4f,Z=%6.4f"), z,objX,objY,objZ); +#endif + + //DP1_IMAGIC(_L("####### SELECTED =====> %d"), selectedIndex); + + return (aResultIndex != -1)? ETrue: EFalse; + } + +// --------------------------------------------------------- +// CImagicContainerBrowser::GetMaxX() +// --------------------------------------------------------- +// +TReal CImagicContainerBrowser::GetMaxX() const + { + TInt images = iIEngine->GetTotalNumOfImages(); + return images > 0 ? iIEngine->GetImageData(images - 1)->iGridData.iX : 0; + } + +// --------------------------------------------------------- +// CImagicContainerBrowser::FindImageInOGl( +// const FloatCoords aPos, TInt& aResultIndex) +// --------------------------------------------------------- +// +TBool CImagicContainerBrowser::FindNearestImageInOGl(const FloatCoords aPos, TInt& aResultIndex) + { + float width = KSpacingX; + float height = KSpacingY; + float itemX = aPos.iX; + float itemY = aPos.iY; + TInt image_num = iIEngine->GetTotalNumOfImages(); + + DP2_IMAGIC(_L("1: itemXY=(%6.4f,%6.4f)"), itemX, itemY); + + itemX = Max(itemX, 0); + itemX = Min(itemX, GetMaxX()); //image_num / CImagicContainerBrowser::KGridSizeY) * width); + itemY = Max(itemY, 0); + itemY = Min(itemY, (CImagicContainerBrowser::KGridSizeY - 1) * height); + + DP2_IMAGIC(_L("2: itemXY=(%6.4f,%6.4f)"), itemX, itemY); + + aResultIndex = -1; // gives invalid value if not found + + // The ray is linear. Can get xy at a depth by multiply '(a depth)/(near/far depth)' + for (TInt i=0; iGetImageData(i); + GLfloat itemZ = imageData->iGridData.iZ; + GLfloat objx = imageData->iGridData.iX; + GLfloat objy = -imageData->iGridData.iY; + //GLfloat objx = (i / iGridSizeY) * width; + //GLfloat objy = (i % iGridSizeY) * height; + + if (objx-width/2 <= itemX && itemX < objx + width/2) + { + if (objy-height/2 <= itemY && itemY < objy + height/2) + { + aResultIndex = i; + break; + } + } + } + + return (aResultIndex != -1)? ETrue: EFalse; + } + + +// --------------------------------------------------------- +// CImagicContainerBrowser::ConvertCoordsFromScreen2OGl( +// const TPoint aPos, FloatCoords& aCoord) +// --------------------------------------------------------- +// +FloatCoords CImagicContainerBrowser::ConvertCoordsFromScreen2OGl(const TPoint aPos) + { + // Calculte OpenGL coords in current image for OneByOne view + TSize size = this->Size(); + FloatCoords coord; + + // OpenGL coord (-0.5 - +0.5) = (relative position in screen) * (coordinate system) + coord.iX = (((float)aPos.iX / size.iWidth ) - 0.5) * (iDrawOneByOne->GetDrawOneByOneWidth() * 2); + coord.iY = (((float)aPos.iY / size.iHeight) - 0.5) * (iDrawOneByOne->GetDrawOneByOneHeight() * 2); + +// RDebug::Print(_L("ConvertCoordsFromScreen2OGl: aPos(%d,%d)/size(%d,%d)*ortho(%6.4f,%6.4f) = coord(%6.4f,%6.4f)"), +// aPos.iX, aPos.iY, size.iWidth, size.iHeight, iDrawOnebyOneW, iDrawOnebyOneH, coord.iX, coord.iY); + + // scale -> translate -> rotate when display + // translate -> scale on calculation. TODO: rotate needs to be considered. + coord.iX = (coord.iX + iDrawOneByOne->GetDrawOneByOneXY().iX) / iDrawOneByOne->GetDrawOneByOneZoom(); + coord.iY = (coord.iY - iDrawOneByOne->GetDrawOneByOneXY().iY) / iDrawOneByOne->GetDrawOneByOneZoom(); + +// RDebug::Print(_L("ConvertCoordsFromScreen2OGl: coord(%6.4f,%6.4f)+trans(%6.4f,%6.4f)*zoom(%6.4f)"), +// coord.iX, coord.iY, iDrawOneByOneX, iDrawOneByOneY, iDrawOneByOneZoom); + + return coord; + } + + +// --------------------------------------------------------- +// CImagicContainerBrowser::FindNearestFace( +// const TPoint aPos, TInt& aResultIndex) +// --------------------------------------------------------- +// +TBool CImagicContainerBrowser::FindNearestFace(const TPoint aPos, TInt& aResultIndex) + { + DP0_IMAGIC(_L("CImagicContainerBrowser::FindNearestFace++")); + + // number of faces in current image(iCurrentIndex). iCoordinates must be already set + TInt facecount = iDrawFaceBrowsing->GetFaceCount(); + + TBool isCloseEnough = EFalse; + TBool found = EFalse; + float closestDistance = 0.0; // this is actully square of distance. + +// ConvertScreenCoords2QvgaCoords(TPoint& aPoint, TRect& aRect) + + FloatCoords coord = ConvertCoordsFromScreen2OGl(aPos); + + if(!GetScreenOrientation()) + { + // swap x and y in portrait + float temp = coord.iX; + coord.iX = -coord.iY; + coord.iY = temp ; + } + + DP4_IMAGIC(_L("CImagicContainerBrowser::FindNearestFace: aPos(%d,%d) => Coord(%6.4f,%6.4f)"),aPos.iX,aPos.iY,coord.iX,coord.iY); + + for(TInt i=0; iConvertCoordsFromAlgo2OGl(i); + + DP3_IMAGIC(_L("CImagicContainerBrowser::FindNearestFace: ====> face %d(%6.4f,%6.4f)"), i, tmp.iX,tmp.iY); + + float distance; + float diff_x = Abs(tmp.iX - coord.iX); + float diff_y = Abs(tmp.iY - coord.iY); + + distance = diff_x*diff_x + diff_y*diff_y; + + DP3_IMAGIC(_L("CImagicContainerBrowser::FindNearestFace: diff x=%6.4f, y=%6.4f. distance=%8.5f)"), diff_x, diff_y, distance); + + if (distance < closestDistance || !found) + { + found = ETrue; + aResultIndex = i; + closestDistance = distance; + } + + if (distance < KFindFaceSearchRange) isCloseEnough = ETrue; + } + + DP1_IMAGIC(_L("CImagicContainerBrowser::FindNearestFace(%d)--"), isCloseEnough); + + return isCloseEnough; + } + + +// --------------------------------------------------------- +// CImagicContainerBrowser::HandleGestureBeganL( +// const TPoint& aPos) +// --------------------------------------------------------- +// +void CImagicContainerBrowser::HandleGestureBeganL(const TPoint& aPos) + { + DP0_IMAGIC(_L("CImagicContainerBrowser::HandleGestureBeganL")); + // do nothing +#ifdef SELECT_ON_TOUCHDOWN + TInt sel; + + if ((iDrawFunction == EGrid) && FindImageInScreen(aPos, sel)) { + iCurrentIndex = sel; + iDrawNow = ETrue; + } +#endif + +#ifdef MOMENTUM_MOVE + iMomentumMove = EFalse; +#endif + +#ifdef RD_FACEFRAME + //iDrawFaceFrame = ETrue; + iDrawNow = ETrue; +#endif + } + +// --------------------------------------------------------- +// CImagicContainerBrowser::HandleGestureMovedL( +// const TPoint& aPos, const TGestureType aType) +// --------------------------------------------------------- +// +void CImagicContainerBrowser::HandleGestureMovedL(const TPoint& aPos, const TGestureType aType) + { + DP0_IMAGIC(_L("CImagicContainerBrowser::HandleGestureMovedL++")); + + if (IS_GESTURE_TAPnDRAG(aType)) // tap&drag for zoom and rotate + { + DP0_IMAGIC(_L("IS_GESTURE_TAPnDRAG")); + // Gesture movement and coord movement are opposite. EFalse for no wrap + DoTapAndDrag(aPos, aType); + } + else if (IS_GESTURE_DRAG(aType)) // just a drag. not Tap and Drag + { + DP0_IMAGIC(_L("IS_GESTURE_DRAG")); + // actions for dragging + // This drag event occurs even finger movement is still within tap threshold + DoDrag(aPos, aType); +#ifdef HOLD_SELECTION_ONDRAG + iHoldSelection = ETrue; +#endif + } + else if (IS_GESTURE_CURSORSIMULATION(aType)) + { + DP0_IMAGIC(_L("IS_GESTURE_CURSORSIMULATION")); + DoCursorSimulation(aPos, aType); + } + else if (IS_GESTURE_LONGTAPPING(aType)) + { + DP0_IMAGIC(_L("IS_GESTURE_LONGTAPPING")); + DoLongTapping(aPos, aType); + } + + DP0_IMAGIC(_L("CImagicContainerBrowser::HandleGestureMovedL--")); + } + +// --------------------------------------------------------- +// CImagicContainerBrowser::HandleGestureEndedL( +// const TPoint& aPos, const TGestureType aType) +// --------------------------------------------------------- +// +void CImagicContainerBrowser::HandleGestureEndedL(const TPoint& aPos, const TGestureType aType) + { +#ifdef HOLD_SELECTION_ONDRAG + // User doesn't touching screen and auto-move can start + iHoldSelection = EFalse; +#endif +#ifdef RD_FACEFRAME + //iDrawFaceFrame = EFalse; +#endif + +// TODO: FIXME: unno temp fix endless cursor movement. +// These need to be set false when key was released. TODO: how to do in dragging in touch... + iTouchMoveData.iRight = EFalse; + iTouchMoveData.iLeft = EFalse; + iTouchMoveData.iUp = EFalse; + iTouchMoveData.iDown = EFalse;//*mika* + + iOnTheEdge=EFalse; + + if (IS_GESTURE_SINGLETAP(aType)) + { + DoSingleTap(aPos, aType); + } + else if (IS_GESTURE_DOUBLETAP(aType)) + { + DoDoubleTap(aPos, aType); + } + else if (IS_GESTURE_LONGTAP(aType)) + { + DoLongTap(aPos, aType); + } + else // Then DoFlick if not single/double tap + { + DoFlick(aPos, aType); + } + + // Disable MagGlass when user releases finger + ShowMagGlass(EFalse); + + //Set normal display draw speed if we were in low draw freq +#ifdef USE_LOW_DRAW_SPEED_WHILE_LOADING + SetDrawFreqToNormal(KTouchDelay); +#endif + } + +void CImagicContainerBrowser::DoTapAndDrag(const TPoint& /*aPos*/, const TGestureType aType) + { +#ifdef TAP_AND_GESTURE + // unno experimental code + if (aType & EGestureUp) + { + iTouchMoveData.iZoomOut=ETrue; + iDrawNow = ETrue; + } + if (aType & EGestureDown) + { + iTouchMoveData.iZoomIn=ETrue; + iDrawNow = ETrue; + } + if (aType & EGestureLeft) + { + iTouchMoveData.iRotate -= 1; + iDrawNow = ETrue; + } + if (aType & EGestureRight) + { + iTouchMoveData.iRotate += 1; + iDrawNow = ETrue; + } +#endif + } + +void CImagicContainerBrowser::DoCursorSimulation(const TPoint& /*aPos*/, const TGestureType aType) + { + DP0_IMAGIC(_L("CImagicContainerBrowser::DoCursorSimulation++")); + + TInt x = 0, y = 0; + TBool wrap = (iDrawFunction == EGrid)? EFalse: ETrue; + + // do nothing if it's in the mode with no cursor simulation +#ifndef CURSORSIMULATION_IN_GRID + if (iDrawFunction == EGrid) return; +#endif + +#ifndef CURSORSIMULATION_IN_ONEBYONE +#ifdef HOLD_SELECTION_ONDRAG + if (iDrawFunction == EOneByOne) return; +#else + if (((iDrawFunction == EOneByOne) && (!IS_NOT_IN_ZOOM_ONEBYONE))) return; + + // allow only left&right to move prev/next image. (do nothing if up or down) + if((iDrawFunction == EOneByOne) && ((aType & EGestureUp) || (aType & EGestureDown))) return; +#endif // HOLD_SELECTION_ONDRAG +#endif + + // cursor move for dragging + if (aType & EGestureUp) ++y; + if (aType & EGestureDown) --y; + if (aType & EGestureLeft) ++x; + if (aType & EGestureRight) --x; + + DP3_IMAGIC(_L("CImagicContainerBrowser::DoCursorSimulation : aType=%d, x=%d, y=%d"), aType, x, y); + + if (x || y) // move index only if x or y are changed + MoveIndex(x, y, wrap); + + DP0_IMAGIC(_L("CImagicContainerBrowser::DoCursorSimulation--")); + } + +void CImagicContainerBrowser::DoDrag(const TPoint& aPos, const TGestureType aType) + { + DP0_IMAGIC(_L("CImagicContainerBrowser::DoDrag++")); + + //ResetTouchData();//mika to test if "stucking" problem is fixed + ResetKeyData(); + ResetTouchData(); + ResetDirKeyData(); + +#ifdef HOLD_SELECTION_ONDRAG + float minX, maxX, minY, maxY; + TInt num = iIEngine->GetTotalNumOfImages(); +#endif +#ifndef CURSORSIMULATION_IN_ONEBYONE + TSize size = this->Size(); + FloatCoords coord; +#endif + + // do nothing if it's stationally (not beyond tap threshold) + if (IS_GESTURE_STATIONARY(aType)) return; + + //iDrawNow = ETrue; + + switch (iDrawFunction) + { + case EGrid: +#ifdef HOLD_SELECTION_ONDRAG + // Drag to shift view + coord.iX = (GLfloat)aPos.iX / 120; //160; // TODO: calc right value from z coord & scale + coord.iY = (GLfloat)aPos.iY / 90; //120; // TODO: calc right value from z coord & scale + + minX = -KSpacingX/2; // allow to move one-picture-size away from the edge + maxX = +KSpacingX/2 + GetMaxX(); + + minY = 0; // don't allow to move away from the edge + maxY = (CImagicContainerBrowser::KGridSizeY-1)*KSpacingY; + + if (iDrawGrid->GetGridXY().iX < minX - minX || maxX + minX < iDrawGrid->GetGridXY().iX) coord.iX /= 3; + if (iDrawGrid->GetGridXY().iY < minY - minY || maxY + minY < iDrawGrid->GetGridXY().iY) coord.iY /= 3; + + TGridXY tmp = iDrawGrid->GetGridXY(); + tmp.iX -= coord.iX; + tmp.iY -= coord.iY; + CheckLimits(tmp.iX, minX, maxX); + CheckLimits(tmp.iY, minY, maxY); + iDrawGrid->SetGridXY(tmp); +#endif + break; + case EOneByOne: +#ifndef CURSORSIMULATION_IN_ONEBYONE + if (!IS_NOT_IN_ZOOM_ONEBYONE) + { + // Drag only in zoomed image + coord.iX = (((float)aPos.iX / size.iWidth ) * (iDrawOneByOne->GetDrawOneByOneWidth() * 2)) / iDrawOneByOne->GetDrawOneByOneZoom(); + coord.iY = (((float)aPos.iY / size.iHeight) * (iDrawOneByOne->GetDrawOneByOneHeight() * 2)) / iDrawOneByOne->GetDrawOneByOneZoom(); + + iDrawOneByOne->ChangeDrawOneByOneTargetX(-coord.iX); + iDrawOneByOne->ChangeDrawOneByOneTargetY(-coord.iY); + } +#ifdef HOLD_SELECTION_ONDRAG + else if (!iDrawOneByOne->IsMagGlassOn() /*iMagGlassOn*/) // not in zoom, magglass off + { + // drag in x coord direction to move prev/next image + coord.iX = (((float)aPos.iX / size.iWidth ) * (iDrawOneByOne->GetDrawOneByOneWidth() * 2)) / iDrawOneByOne->GetDrawOneByOneZoom(); + //iOneByOneFlow += coord.iX; + float tmp = iDrawOneByOne->GetImgeFlowLocation(); + tmp+=coord.iX; + iDrawOneByOne->SetImgeFlowLocation(tmp); + + iOneByOneSlideByDrag = ETrue; + DP1_IMAGIC(_L("Sliding iOneByOneFlow=%6.4f"), iDrawOneByOne->GetImgeFlowLocation()); + } +#endif // HOLD_SELECTION_ONDRAG +#endif + break; + case EFaceBrowser: +// TODO: Integrate face browing and dragging! + + DP0_IMAGIC(_L("CImagicContainerBrowser::DoDrag - EFaceBrowser")); + //DoFlick(aPos, aType); + default: + break; + } + + iDrawNow = ETrue; + + DP0_IMAGIC(_L("CImagicContainerBrowser::DoDrag--")); + + } + +void CImagicContainerBrowser::DoFlick(const TPoint& aPos, const TGestureType aType) + { + DP0_IMAGIC(_L("CImagicContainerBrowser::DoFlick++")); + + //ResetTouchData();//mika to test if "stucking" problem is fixed + +#ifndef CURSORSIMULATION_IN_ONEBYONE + TSize size = this->Size(); + FloatCoords coord; +#endif +#ifdef MOMENTUM_MOVE + float vX, vY, tX, tY; + float minX, maxX; +#ifndef FLICK_ONLY_IN_X_IN_GRID + float minY, maxY; +#endif + TInt x, y, absX, absY; + TBool valid_x, valid_y; + TInt num = iIEngine->GetTotalNumOfImages(); +#endif + + iDrawNow = ETrue; + + switch (iDrawFunction) + { + case EGrid: + DP0_IMAGIC(_L("CImagicContainerBrowser::DoFlick - EGrid")); +#ifdef MOMENTUM_MOVE + // TODO: FIXME: Good value needed. Not 180. Consider non-liner speed. + // TODO: 128 should be the size of images in Screen (pixels) at z = 0 (not zoomed) +const TInt FLICKUNIT=128; // movement of 128 px/s = 1 flick unit speed +//const TInt FLICK_2ND_GEAR = 8; +const TInt FLICK_2ND_GEAR = 16; +const TInt FLICK_3ND_GEAR = 8; + x = aPos.iX; + y = aPos.iY; + absX = Abs(x); + absY = Abs(y); + + valid_x = (absX && (absX * 5 > absY * 3))? ETrue: EFalse; + valid_y = (absY && (absY * 5 > absX * 4))? ETrue: EFalse; + + if (!valid_x || (absX < FLICKUNIT / 3)) + { + vX = tX = 0.0f; + } + else if (absX < FLICKUNIT) + { + vX = ((float)x / absX) * KSpacingX; + tX = ( x / absX) * KSpacingX; + + if (tX>0 && iDrawGrid->GetGridTargetXY().iX < iDrawGrid->GetGridXY().iX) tX = 0; + if (tX<0 && iDrawGrid->GetGridTargetXY().iX > iDrawGrid->GetGridXY().iX) tX = 0; + } + else if (absX < FLICKUNIT * FLICK_2ND_GEAR) + { + vX = ((float)x / FLICKUNIT) * KSpacingX; + tX = ( x / FLICKUNIT) * KSpacingX; + } + else + { + float u = absX / FLICKUNIT; + float v = u*u - 2*FLICK_3ND_GEAR*u + FLICK_3ND_GEAR*FLICK_3ND_GEAR + FLICK_3ND_GEAR; + if (x < 0) v = -v; + vX = ((float)v) * KSpacingX; + tX = ( v) * KSpacingX; + } + + vY = (valid_y)? ((float)y / FLICKUNIT) * KSpacingY: 0.0f; + tY = (valid_y)? ( y / FLICKUNIT) * KSpacingY: 0.0f; + + DP4_IMAGIC(_L("vX/Y=(%6.4f, %6.4f), tX/Y=(%6.4f,%6.4f)"), vX, vY, tX, tY); + DP2_IMAGIC(_L("aPos.iX/Y=(%d,%d)"), aPos.iX, aPos.iY); + + iMomentumMove = ETrue; + + iMomentumSpeedX = Abs(vX); + //iDrawGridTargetX += (-tX); + TGridXY tmp = iDrawGrid->GetGridTargetXY(); + tmp.iX += (-tX); + + minX = -KSpacingX/2; // allow to move one-picture-size away from the edge + maxX = +KSpacingX/2 + GetMaxX(); + + //CheckLimits(iDrawGridTargetX, minX, maxX); + CheckLimits(tmp.iX, minX, maxX); + iDrawGrid->SetGridTargetXY(tmp); + +#ifndef FLICK_ONLY_IN_X_IN_GRID + iMomentumSpeedY = Abs(vY); + iDrawGridTargetY += (-tY); + minY = 0; // don't allow to move away from the edge + maxY = (iGridSizeY-1)*KSpacingY; + CheckLimits(iDrawGridTargetY, minY, maxY); +#else + iMomentumSpeedY = 0; +#endif +#endif + break; + case EOneByOne: + DP0_IMAGIC(_L("CImagicContainerBrowser::DoFlick - EOneByOne")); + +#ifndef CURSORSIMULATION_IN_ONEBYONE + vX = (float)aPos.iX / 2; // pixels of movement in 0.5 sec + vY = (float)aPos.iY / 2; + + coord.iX = ((vX / size.iWidth ) * (iDrawOneByOne->GetDrawOneByOneWidth() * 2)) / iDrawOneByOne->GetDrawOneByOneZoom(); + coord.iY = ((vY / size.iHeight) * (iDrawOneByOne->GetDrawOneByOneHeight() * 2)) / iDrawOneByOne->GetDrawOneByOneZoom(); + + iDrawOneByOne->ChangeDrawOneByOneTargetX(-coord.iX); + iDrawOneByOne->ChangeDrawOneByOneTargetY(-coord.iY); + +#endif +#ifdef HOLD_SELECTION_ONDRAG + // Find current index if sliding is done by dragging in OneByOne view + // iOneByOneSlideByDrag is set EFalse in HandleMovingKeysOneByOne() + // Flick is not currently affecting even though this is in DoFlick() + DP2_IMAGIC(_L("Checking iOneByOneSlideByDrag (%d), iOneByOneFlow=%6.4f"), iOneByOneSlideByDrag, iDrawOneByOne->GetImgeFlowLocation()); + if (iOneByOneSlideByDrag) + { + if (iDrawOneByOne->GetImgeFlowLocation() > +KOneByOneSpacing / 10) + MoveIndex(-1, 0, ETrue); + if (iDrawOneByOne->GetImgeFlowLocation() < -KOneByOneSpacing / 10) + MoveIndex(+1, 0, ETrue); + } +#endif + break; + case EFaceBrowser: + DP0_IMAGIC(_L("CImagicContainerBrowser::DoFlick - EFaceBrowser")); + if(GetScreenOrientation()) + { + if (aType & EGestureLeft) MoveIndex( 1, 0, ETrue); + if (aType & EGestureRight) MoveIndex(-1, 0, ETrue); + } + else + { + if (aType & EGestureDown) MoveIndex( 1, 0, ETrue); + if (aType & EGestureUp) MoveIndex(-1, 0, ETrue); + } + break; + default: + break; + } + + //ResetTouchData();//mika to test if "stucking" problem is fixed + + DP0_IMAGIC(_L("CImagicContainerBrowser::DoFlick--")); + } + +void CImagicContainerBrowser::DoSingleTap(const TPoint& aPos, const TGestureType /*aType*/) + { + DP0_IMAGIC(_L("CImagicContainerBrowser::DoSingleTap++")); + + //ResetTouchData();//mika to test if "stucking" problem is fixed + + TInt sel; + + switch (iDrawFunction) + { + case EGrid: + if (FindImageInScreen(aPos, sel)) // do nothing if user touches none + { + if (iCurrentIndex == sel) + { + SelectIndex(); // Open image if user touches current image + } + else + { + iCurrentIndex = sel; // focus touched image if it's not current one + iDrawNow = ETrue; + } + } + break; + case EOneByOne: + // TODO: Add face browsing by signle tap, maybe on zoom? + DP1_IMAGIC(_L("DoSingleTap:iDrawOneByOneZoom=%6.4f"), iDrawOneByOne->GetDrawOneByOneZoom()); + if (IS_NOT_IN_ZOOM_ONEBYONE) + { + /*TInt dx = 50 - aPos.iX; + TInt dy = 50 - aPos.iY; + + // start face browing if user taps at top left when face icon is shown + if (iFaceExists && (dx*dx + dy*dy < 50*50)) + iView->HandleCommandL(EImagicCmdViewFaceBrowsing); + else*/ + SelectIndex(); // exits only when non zoomed. + } +#ifdef SINGLETAP_CLOSE_IN_ZOOM + else + { + // Stop zooming if it's in zoom + //iDrawOneByOne->SetDrawOneByOneTargetZoom(KDoubleTapZoomOneByOne1);//mika, single tap disabled in zzomed in picture + iDrawNow = ETrue; + } +#endif + break; + case EFaceBrowser: +#ifdef SINGLETAP_CLOSE_IN_ZOOM + // TODO: FIXME. Temporary hack to start OnebyOne view. Pretend it's grid and do select action + //iDrawFunction = EGrid; + //SetDrawMode(EGrid); + /*SelectIndex(); + SetDrawMode(EOneByOne);*/ + +#endif + break; + default: + break; + } + + DP0_IMAGIC(_L("CImagicContainerBrowser::DoSingleTap--")); + + } + +void CImagicContainerBrowser::DoDoubleTap(const TPoint& aPos, const TGestureType /*aType*/) + { + DP0_IMAGIC(_L("CImagicContainerBrowser::DoDoubleTap++")); + + //ResetTouchData();//mika to test if "stucking" problem is fixed + +#ifdef DOUBLETAP_SELECT_IN_GRID + TInt sel; +#endif + iDrawNow = ETrue; + + switch (iDrawFunction) + { +#define TOGGLE_VALUE(tgt, val1, val2) (tgt)=((tgt)!=(val1))?(val1):(val2) + case EGrid: +#ifdef DOUBLETAP_SELECT_IN_GRID + if (FindImageInScreen(aPos, sel)) // do nothing if user touches none + { + iCurrentIndex = sel; // focus touched image if it's not current one + SelectIndex(); // Open image if user touches current image + } +#endif +#ifdef ENABLE_GRID_ZOOM +#ifdef DOUBLETAP_ZOOMGRID + TOGGLE_VALUE(iDrawGridTargetZoom, KDoubleTapZoomGrid1, KDoubleTapZoomGrid2); +#endif +#endif + break; + case EOneByOne: +#ifdef DOUBLETAP_FACEBROWSING + if (IS_NOT_IN_ZOOM_ONEBYONE) + { + iView->HandleCommandL(EImagicCmdViewFaceBrowsingWithCoordinates); + } +#endif + // toggle zooming on and off if MagGlass is off + if(!iDrawOneByOne->IsMagGlassOn()/*iMagGlassOn*/) + { + //TOGGLE_VALUE(iDrawOneByOneTargetZoom, KDoubleTapZoomOneByOne1, KDoubleTapZoomOneByOne2); + if(iDrawOneByOne->GetDrawOneByOneTargetZoom() == KDoubleTapZoomOneByOne1) + iDrawOneByOne->SetDrawOneByOneTargetZoom(KDoubleTapZoomOneByOne2); + else + iDrawOneByOne->SetDrawOneByOneTargetZoom(KDoubleTapZoomOneByOne1); + } + + if (iDrawOneByOne->GetDrawOneByOneTargetZoom() == KDoubleTapZoomOneByOne2) + { + // if we are zooming in, tapped position is set as center + TSize size = this->Size(); + float imageWidth, imageHeight; + CalculateImageSize(imageWidth, imageHeight, (float)size.iWidth/(float)size.iHeight); + + /*iDrawOneByOneTargetX = (2*iImageWidth) *(((float)aPos.iX / size.iWidth ) - 0.5); + iDrawOneByOneTargetY = (2*iImageHeight)*(((float)aPos.iY / size.iHeight) - 0.5);*/ + TDrawOneByOneXY tmp; + tmp.iX = (2*imageWidth) *(((float)aPos.iX / size.iWidth ) - 0.5); + tmp.iY = (2*imageHeight)*(((float)aPos.iY / size.iHeight) - 0.5); + iDrawOneByOne->SetDrawOneByOneTargetXY(tmp); + + /*if(!GetScreenOrientation()) + { + float tmp = iDrawOneByOneTargetX; + iDrawOneByOneTargetX = -iDrawOneByOneTargetY; + iDrawOneByOneTargetY = tmp; + }*/ + } + break; + case EFaceBrowser: +#ifdef DOUBLETAP_FACEBROWSING + // TODO: FIXME. Temporary hack to start OnebyOne view. Pretend it's grid and do select action + //iDrawFunction = EGrid; + drawZoom = 1; inPictureX = 0; inPictureY = 0; + iDrawFaceBrowsing->GetFBZoomAndLocation(drawZoom, inPictureX, inPictureY); + iDrawOneByOne->InitDrawOnebyOne(drawZoom, inPictureX, inPictureY); + + SelectIndex(); + SetDrawMode(EOneByOne/*EGrid*/); +#endif + break; + } + + DP0_IMAGIC(_L("CImagicContainerBrowser::DoDoubleTap--")); + } + +void CImagicContainerBrowser::DoLongTapping(const TPoint& aPos, const TGestureType aType) + { + DP1_IMAGIC(_L("CImagicContainerBrowser::DoLongTapping aPos.iX: %d"), aPos.iX); + DP1_IMAGIC(_L("CImagicContainerBrowser::DoLongTapping aPos.iY: %d"), aPos.iY); + + //ResetTouchData();//mika to test if "stucking" problem is fixed + + // touch movement is stationary for enough long time + switch (iDrawFunction) + { + case EOneByOne: + ShowMagGlass(ETrue); + break; + case EGrid: + iView->ProcessCommandL(EAknSoftkeyOptions); + /*TInt sel; + if (FindImageInScreen(aPos, sel)) // do nothing if user touches none + { + if (iCurrentIndex == sel) + { + iView->ProcessCommandL(EAknSoftkeyOptions); + //iView->ProcessCommandL(EImagicCmdViewBrowserShowImageInfo); + } + }*/ + + /*else if(aPos.iX > 100) + { + iView->ProcessCommandL(EAknSoftkeyOptions); + }*/ +#if 0 + else + { + //iView->ProcessCommandL(EAknSoftkeyOptions); + } +#endif + //iView->ProcessCommandL(EAknSoftkeyOptions);//TODO, options should be shown from softkeys + break; + + case EFaceBrowser: + break; + default: + // do nothing + break; + } + + iDrawNow = ETrue; + + } + +void CImagicContainerBrowser::DoLongTap(const TPoint& aPos, const TGestureType aType) + { + // do nothing so far. + iDrawNow = ETrue; + } + +// --------------------------------------------------------- +// CImagicContainerBrowser::MoveIndex( +// TInt aMoveX, TInt aMoveY, TBool aWrap) +// --------------------------------------------------------- +// +void CImagicContainerBrowser::MoveIndex(TInt aMoveX, TInt aMoveY, TBool aWrap) + { + DP0_IMAGIC(_L("CImagicContainerBrowser::MoveIndex++")); + + TInt num = iIEngine->GetTotalNumOfImages(); + // Reset key data + iTouchMoveData.iRight = EFalse; + iTouchMoveData.iLeft = EFalse; + iTouchMoveData.iUp = EFalse; + iTouchMoveData.iDown = EFalse;//*mika* + iTouchMoveData.iX = 0; + iTouchMoveData.iY = 0; + + if (aMoveX < 0) // left key press + { + if (aWrap || iCurrentIndex >= CImagicContainerBrowser::KGridSizeY) + { + if(iDrawFunction == EFaceBrowser) + //iFaceNro--; // prev face in face browser + iDrawFaceBrowsing->DecFaceNumber(); + else + { + iTouchMoveData.iX = aMoveX; + iTouchMoveData.iLeft = ETrue; + } + iDrawNow = ETrue; + } + } + + if (aMoveX > 0) // right key press + { + if (aWrap || iCurrentIndex < num - CImagicContainerBrowser::KGridSizeY) + { + if(iDrawFunction == EFaceBrowser) + //iFaceNro++; // next face in face browser + iDrawFaceBrowsing->IncFaceNumber(); + else + { + iTouchMoveData.iX = aMoveX; + iTouchMoveData.iRight = ETrue; + } + iDrawNow = ETrue; + } + } + + if (aMoveY < 0) // up key press + { + if (aWrap || iCurrentIndex % CImagicContainerBrowser::KGridSizeY > 0) + { + iTouchMoveData.iY = aMoveY; + iTouchMoveData.iUp = ETrue; + iDrawNow = ETrue; + } + } + + if (aMoveY > 0) // down key press + { + if ( aWrap || + ((iCurrentIndex % CImagicContainerBrowser::KGridSizeY < CImagicContainerBrowser::KGridSizeY - 1) && + (iCurrentIndex < num - 1))) + { + iTouchMoveData.iY = aMoveY; + iTouchMoveData.iDown = ETrue; + iDrawNow = ETrue; + } + } + + DP0_IMAGIC(_L("CImagicContainerBrowser::MoveIndex--")); + } + +// --------------------------------------------------------- +// CImagicContainerBrowser::SelectIndex( +// void) +// --------------------------------------------------------- +// +void CImagicContainerBrowser::SelectIndex(void) + { + DP0_IMAGIC(_L("CImagicContainerBrowser::SelectIndex++")); + + iDrawNow = ETrue; + + if(iDrawFunction == EGrid) + { + //Open one by one mode + iDrawOneByOne->InitDrawOnebyOne(KInitDrawZoom/*drawZoom*/, inPictureX, inPictureY); + + //Set Grid view + if(iDrawFunction == EFaceBrowser) + { + //iDrawFunction = EGrid; + SetDrawMode(EGrid); + } + + iView->SetFaceBrowsingMode(EFaceBrowserNone); + } + else if(iDrawFunction == EOneByOne) + { +/*#ifdef SUPERZOOM + //Unload high res textures when going back to Grid + CImageData* aGridData = iIEngine->GetImageData(iCurrentIndex); + iTextureLoader->ReleaseSuperHResTexture( aGridData ); +#endif*/ + + //Return to previous mode + iDrawGrid->InitDrawGrid(); + //iDrawFunction = iDrawOneByOnePreviousFunc; + //iDrawFunction = EGrid; + SetDrawMode(EGrid); + iView->SetFaceBrowsingMode(EFaceBrowserNone); + } + else if(iDrawFunction == EFaceBrowser) + { + iDrawGrid->InitDrawGrid(); + //iDrawFunction = EGrid; + //SetDrawMode(EGrid); + SetDrawMode(EOneByOne); + } + + DP0_IMAGIC(_L("CImagicContainerBrowser::SelectIndex--")); + } + +//#endif + +void CImagicContainerBrowser::SetLoadingOn(TBool aValue) + { + DP0_IMAGIC(_L("CImagicContainerBrowser::SetLoadingOn++")); + DP1_IMAGIC(_L("CImagicContainerBrowser::SetLoadingOn - value: %d"), aValue); + + iDynamicLoadingOn = aValue; + //iDrawNow = ETrue; + + DP0_IMAGIC(_L("CImagicContainerBrowser::SetLoadingOn--")); + } + + +void CImagicContainerBrowser::ImageLoadedL(TInt aError, CFbsBitmap* aBitmap, TThumbSize aResolution) + { + DP0_IMAGIC(_L("CImagicContainerBrowser::ImageLoadedL++")); + + //Check do we need to unload or load more images ------> + //LoadUnloadImages(); + DynamicUnLoading(); + + TInt mem = 0; + TInt ret = HAL::Get(HALData::EMemoryRAMFree, mem); + DP1_IMAGIC(_L("CImagicContainerBrowser::ImageLoadedL - Free RAM: %d"), mem); + + if(mem <= 16000000){ + DP0_IMAGIC(_L("CImagicContainerBrowser::ImageLoadedL - buffer size: 1")); + K512TNImageBuffer = 1; + } + if(mem <= 20000000){ + DP0_IMAGIC(_L("CImagicContainerBrowser::ImageLoadedL - buffer size: 2")); + K512TNImageBuffer = 2; + } + if(mem > 24000000){ + DP0_IMAGIC(_L("CImagicContainerBrowser::ImageLoadedL - buffer size: 3")); + K512TNImageBuffer = 3; + } + if(mem > 28000000){ + DP0_IMAGIC(_L("CImagicContainerBrowser::ImageLoadedL - buffer size: 4")); + K512TNImageBuffer = 4; + } + if(mem > 32000000){ + DP0_IMAGIC(_L("CImagicContainerBrowser::ImageLoadedL - buffer size: 5")); + K512TNImageBuffer = 5; + } + + if(aResolution == ESize512x512 || aResolution == EFullSize) + { + iPreferHighResLoading = EFalse; + iDynamicLoadingOn = ETrue; + DynamicLoadingL(); + } + + iTextureLoader->ImageLoadedL(aError, aBitmap, iGLMaxRes); + + DP0_IMAGIC(_L("CImagicContainerBrowser::ImageLoadedL--")); + } + + +//This is correcting the aspact ratio to be correct for OpengGL drawing +void CImagicContainerBrowser::SetPictureVertices(CImageData* aData, GLfixed* aVertices) + { + //DP0_IMAGIC(_L("CImagicContainerBrowser::SetPictureVertices")); + + GLfixed vx, vy; + + // Use real image + if(aData->iGridData.iGlLQ128TextIndex != 0 || + aData->iGridData.iGlLQ32TextIndex != 0 || + aData->iGridData.iGlHQ512TextIndex != 0) + { + if(aData->GetAspectRatio() > 1) + { + vx = 1<<15; + vy = (0.5/aData->GetAspectRatio())*(1<<16); + } + else + { + vx = (0.5*aData->GetAspectRatio())*(1<<16); + vy = 1<<15; + } + } + // Use loading image + else + { + vx = 24000; + vy = vx / KLoadingImageAspectRatio; + } + + 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; + + } + +void CImagicContainerBrowser::DisplayDeleteQueryDialogL(TInt aResourceId) + { + CAknQueryDialog* dlg; + dlg = new ( ELeave ) CAknQueryDialog(); + TInt result = dlg->ExecuteLD( aResourceId ); + if(result != KErrNone) + { + //Delete file + DeleteImageL(); + } + } + +//Delete current image +void CImagicContainerBrowser::DeleteImageL() + { + DP0_IMAGIC(_L("CImagicContainerBrowser::DeleteImageL++")); + + //Delete image from engine + //Delete grid image from OpenGL memory + //TInt num = iIEngine->GetTotalNumOfImages(); + CImageData* data = iIEngine->GetImageData(iCurrentIndex); + + if(data->iGridData.iGlLQ128TextIndex) + glDeleteTextures( 1, &data->iGridData.iGlLQ128TextIndex ); + if(data->iGridData.iGlLQ32TextIndex) + glDeleteTextures( 1, &data->iGridData.iGlLQ32TextIndex ); + if(data->iGridData.iGlHQ512TextIndex != 0) + glDeleteTextures(1, &data->iGridData.iGlHQ512TextIndex); + if(data->iGridData.iGlSuperHQTextIndex != 0) + glDeleteTextures(1, &data->iGridData.iGlSuperHQTextIndex); + + data->iGridData.iGlLQ32TextIndex = 0; + data->iGridData.iGlLQ128TextIndex = 0; + data->iGridData.iGlHQ512TextIndex = 0; + data->iGridData.iGlSuperHQTextIndex = 0; + + //Delete image from engine + TInt err = iImagicAppUi->DeleteImage(iCurrentIndex); + if (err != KErrNone) + { + iImagicAppUi->GetImagicUtils()->ExecuteQueryDialog(R_CANNOT_DELETE_DIALOG); + } + + iDrawOneByOne->SetDrawOneByOneTargetZoom(1); + iDrawNow = ETrue; + + iDrawGrid->UpdateImageCoordinates(iCurrentIndex); + + if(iIEngine->GetTotalNumOfImages() <= 0) + { + iImagicAppUi->GetImagicUtils()->ExecuteQueryDialog(0, R_NO_IMAGES_DIALOG); + } + + DP0_IMAGIC(_L("CImagicContainerBrowser::DeleteImageL--")); + } + + + +//Returns TRUE if screen is landscape +TBool CImagicContainerBrowser::GetScreenOrientation() + { + //Landscape +#ifdef _ACCELEROMETER_SUPPORTED_ + //if(iDeviceOrientation == EOrientationDisplayLeftUp)//Landscape + if(iDeviceOrientation == EOrientationDisplayLeftUp || iDeviceOrientation == EOrientationDisplayRigthUp)//Landscape + { + DP1_IMAGIC(_L("CImagicContainerBrowser::GetScreenOrientation - Landscape: %d"),iDeviceOrientation); + iDeviceOrientationAngle = 0; + return ETrue; + } + else if(iDeviceOrientation == EOrientationDisplayDown) + { + DP1_IMAGIC(_L("CImagicContainerBrowser::GetScreenOrientation - Portrait: %d"),iDeviceOrientation); + iDeviceOrientationAngle = -90; + return EFalse; + } +#else + if(this->Size().iWidth > this->Size().iHeight) + + { + DP1_IMAGIC(_L("CImagicContainerBrowser::GetScreenOrientation - Landscape: %d"),iDeviceOrientation); + return ETrue; + } + else + { + DP1_IMAGIC(_L("CImagicContainerBrowser::GetScreenOrientation - Portrait: %d"),iDeviceOrientation); + return EFalse; + } +#endif + } + +//This should be called when reading touch UI events or key events to set draw freq to normal +void CImagicContainerBrowser::SetDrawFreqToNormal(TInt aTimerDelay) + { + DP0_IMAGIC(_L("CImagicContainerBrowser::SetDrawFreqToNormal++")); + + //Set normal display draw speed if we were in power save + if(iDisplayDrawFreq == KPowerSaveDisplayDrawFreq) + { + iDisplayDrawFreq = KDisplayDrawFreq; + DisableDisplayDraw(); + if(iImagicAppUi->IsAppOnTop()) + EnableDisplayDraw(); + } + //Reset power save timer + iPowerSavePeriodic->Cancel(); + //And start it again, but only if we are loading images + if(iTextureLoader->IsActiveAndRunning() && iDrawFunction == EGrid) + { + iPowerSavePeriodic->Start(/*KPowerSavePeriodicDelay*/aTimerDelay, KPowerSavePeriodicInterval, TCallBack( CImagicContainerBrowser::PowerSaveCallBack, this ) ); + } + + DP0_IMAGIC(_L("CImagicContainerBrowser::SetDrawFreqToNormal--")); + } + +void CImagicContainerBrowser::ResetZoomKeys() + { + iKeyData.iZoomInKey=EFalse; + iKeyData.iZoomOutKey=EFalse; + } + + +TKeyResponse CImagicContainerBrowser::OfferKeyEventL(const TKeyEvent& aKeyEvent, TEventCode aType) + { + DP0_IMAGIC(_L("CImagicContainerBrowser::OfferKeyEventL")); + + //Set normal display draw speed if we were in low draw freq +#ifdef USE_LOW_DRAW_SPEED_WHILE_LOADING + SetDrawFreqToNormal(KPowerSavePeriodicDelay); +#endif + + //if(iImagicAppUi->IsAppOnTop()) + EnableDisplayDraw(); + + iUserInputGiven = ETrue; + iLastEventFromKeys = ETrue; + + TKeyResponse ret = EKeyWasNotConsumed; + + // Set default values + TInt addValue=0; + TBool pressValue=EFalse; + ResetKeyData(); + ResetTouchData(); + ResetDirKeyData(); + iDrawOneByOne->ChangeDrawOneByOneTargetX(0); + iDrawOneByOne->ChangeDrawOneByOneTargetY(0); + + // Set button as pressed and add press counter by one + if (aType == EEventKey) + { + iDrawGrid->KeyEvent(); + iDrawOneByOne->KeyEvent(); + iDrawFaceBrowsing->KeyEvent(); + + iDrawNow = ETrue; + addValue=1; + pressValue=ETrue; + } + + if (aType == EEventKeyDown) + { + iDrawGrid->KeyPressed(); + iDrawOneByOne->KeyPressed(); + iDrawFaceBrowsing->KeyPressed(); + + /*if(iDrawFunction == EOneByOne && IS_NOT_IN_ZOOM_ONEBYONE) + iDrawOneByOne->InitDrawOnebyOne();*/ + + iIntheEndOfGrid = EFalse; + iOnTheEdge=ETrue; + iKeyPressedDown=ETrue; + pressValue=ETrue; + /// + iDrawNow = ETrue; + addValue=1; + } + + if (aType == EEventKeyUp) + { + iDrawGrid->KeyReleased(); + iDrawOneByOne->KeyReleased(); + iDrawFaceBrowsing->KeyReleased(); + + iOnTheEdge=EFalse; + iKeyPressedDown=EFalse; + pressValue=EFalse; + addValue=0; + //iKeyCounter=0; + + if(iIntheEndOfGrid) + iJumpOver = ETrue; + else + iJumpOver = EFalse; + } + + CImageData* imageData = iIEngine->GetImageData(iCurrentIndex); + TInt imageRotation = 0 - (TReal)imageData->GetOrientation(); + + + //if (aType==EEventKey /*|| aType==EEventKeyUp || aType==EEventKeyDown*/) +// if(iKeyCounter == 0) + { + // Assume that key will be handled + ret = EKeyWasConsumed; + + // Check for key + switch (aKeyEvent.iScanCode) + { + // Vertical movement + case EStdKeyDownArrow: + if(iDrawFunction == EOneByOne && IS_NOT_IN_ZOOM_ONEBYONE){ + } + else{ + iKeyData.iY+=addValue; + iKeyData.iDown=pressValue; + } +#ifdef _ACCELEROMETER_SUPPORTED_ + if((iDeviceOrientation == EOrientationDisplayDown && + iDrawFunction == EFaceBrowser && aType == EEventKey)) + { + iDrawFaceBrowsing->DecFaceNumber(); + } + else if( (iDrawFunction == EFaceBrowser && aType == EEventKey && + (imageRotation == -90 || imageRotation == -270)) ) + { + if(imageRotation == -90) + iDrawFaceBrowsing->DecFaceNumber(); + else + iDrawFaceBrowsing->IncFaceNumber(); + } + +#endif + ResetZoomKeys(); + break; + + case EStdKeyUpArrow: + if(iDrawFunction == EOneByOne && IS_NOT_IN_ZOOM_ONEBYONE){ + } + else{ + iKeyData.iY-=addValue; + iKeyData.iUp=pressValue; + } +#ifdef _ACCELEROMETER_SUPPORTED_ + if((iDeviceOrientation == EOrientationDisplayDown && + iDrawFunction == EFaceBrowser && aType == EEventKey)) + { + iDrawFaceBrowsing->IncFaceNumber(); + } + else if( (iDrawFunction == EFaceBrowser && aType == EEventKey && + (imageRotation == -90 || imageRotation == -270)) ) + { + if(imageRotation == -90) + iDrawFaceBrowsing->IncFaceNumber(); + else + iDrawFaceBrowsing->DecFaceNumber(); + } + +#endif + ResetZoomKeys(); + break; + + //Horisontal movement + case EStdKeyLeftArrow: + if( +#ifdef _ACCELEROMETER_SUPPORTED_ + (iDeviceOrientation == EOrientationDisplayLeftUp && +#endif + iDrawFunction == EFaceBrowser && aType == EEventKey) || + + (iDrawFunction == EFaceBrowser && aType == EEventKey && + imageRotation == (imageRotation == -90 || imageRotation == -270)) ) + { + iDrawFaceBrowsing->DecFaceNumber(); + } + iKeyData.iX-=addValue; + iKeyData.iLeft=pressValue; + ResetZoomKeys(); + break; + + case EStdKeyRightArrow: + if( +#ifdef _ACCELEROMETER_SUPPORTED_ + (iDeviceOrientation == EOrientationDisplayLeftUp && +#endif + iDrawFunction == EFaceBrowser && aType == EEventKey) || + + (iDrawFunction == EFaceBrowser && aType == EEventKey && + imageRotation == (imageRotation == -90 || imageRotation == -270)) ) + { + iDrawFaceBrowsing->IncFaceNumber(); + } + iKeyData.iX+=addValue; + iKeyData.iRight=pressValue; + ResetZoomKeys(); + break; + + // Rotation +#if 1 + case '1': + case 'A': + case EStdKeyNkp1: + { + if (/*aType==EEventKey *//*|| aType==EEventKeyUp || */aType==EEventKeyDown) + { + CImageData* imageData = iIEngine->GetImageData(iImagicAppUi->GetImageIndex()); + TInt rotAngle = imageData->GetOrientation(); + imageData->SetOrientation((rotAngle + 90)%360); + iIEngine->SetImageRotation(iImagicAppUi->GetImageIndex()); + iIEngine->SetDBChanged(imageData); + } + + ResetZoomKeys(); + ResetDirKeyData(); + break; + } + + case '3': + case 'S': + case EStdKeyNkp3: + { + if (/*aType==EEventKey *//*|| aType==EEventKeyUp || */aType==EEventKeyDown) + { + CImageData* imageData = iIEngine->GetImageData(iImagicAppUi->GetImageIndex()); + TInt rotAngle = imageData->GetOrientation(); + imageData->SetOrientation((rotAngle + 270)%360); + iIEngine->SetImageRotation(iImagicAppUi->GetImageIndex()); + iIEngine->SetDBChanged(imageData); + } + + ResetZoomKeys(); + ResetDirKeyData(); + break; + } +#endif + + case EStdKeySpace: + case EKeySpace: + case '0': + case EStdKeyNkp0: +#ifdef _ACCELEROMETER_SUPPORTED_ + //Check that accelerometer did not found by engine + DP0_IMAGIC(_L("CImagicContainerBrowser::OfferKeyEvent - rotate pressed")); + if(!iIEngine->IsAccelerometerExists() && aType == EEventKeyDown) + { + if(iIEngine->GetDeviceOrientation() == EOrientationDisplayLeftUp) + iIEngine->SetDeviceOrientation(EOrientationDisplayDown); + else if(iIEngine->GetDeviceOrientation() == EOrientationDisplayDown) + iIEngine->SetDeviceOrientation(EOrientationDisplayLeftUp); + } + + ResetZoomKeys(); + ResetDirKeyData(); +#endif + break; + + //case EStdKeySpace: + //case EKeySpace: + case 'M': + if(aType == EEventKeyDown) + { + iView->ProcessCommandL(EAknSoftkeyOptions); + ResetZoomKeys(); + ResetDirKeyData(); + } + break; + + // Zooming + case 'Q': + case EStdKeyNkpAsterisk: + case '*': + case EStdKeyIncVolume: + + ResetDirKeyData(); + + if(iDrawFunction == EOneByOne) + { + //iKeyData.iZoom+=addValue; + //iKeyData.iZoomIn=pressValue; + iKeyData.iZoomInKey=ETrue; + iKeyData.iZoomOutKey=EFalse; + } + if(iDrawFunction == EGrid) + { + //Open one by one mode + iDrawOneByOne->InitDrawOnebyOne(KInitDrawZoom/*drawZoom*/, inPictureX, inPictureY); + //Set Grid view + if(iDrawFunction == EFaceBrowser) + { + //iDrawFunction = EGrid; + SetDrawMode(EGrid); + } + + iView->SetFaceBrowsingMode(EFaceBrowserNone); + } + //ResetDirKeyData(); + break; + + case 'W': + case EStdKeyHash: + case '#': + case EStdKeyDecVolume: + + ResetDirKeyData(); + + if(iDrawFunction == EOneByOne) + { + //iKeyData.iZoom-=addValue; + //iKeyData.iZoomOut=pressValue; + iKeyData.iZoomInKey=EFalse; + iKeyData.iZoomOutKey=ETrue; + } + + if(iDrawFunction == EOneByOne && IS_NOT_IN_ZOOM_ONEBYONE && aType == EEventKeyDown) + { +/*#ifdef SUPERZOOM + iIEngine->CancelFullSizeLoading(); + + //Unload high res textures when going back to Grid + CImageData* aGridData = iIEngine->GetImageData(iCurrentIndex); + iTextureLoader->ReleaseSuperHResTexture( aGridData ); +#endif*/ + //Return to previous mode + iDrawGrid->InitDrawGrid(); + SetDrawMode(EGrid); + + iView->SetFaceBrowsingMode(EFaceBrowserNone); + } + //ResetDirKeyData(); + break; + + /*case 'F': + iView->HandleCommandL(EImagicCmdViewFaceBrowsing); + break;*/ + + case EKeyBackspace: + case EStdKeyBackspace: + iView->HandleCommandL(EImagicCmdViewBrowserDelete); + ResetZoomKeys(); + ResetDirKeyData(); + break; + + case 'I': + if(aType == EEventKeyDown) + { + iView->HandleCommandL(EImagicCmdViewBrowserShowImageInfo); + ResetZoomKeys(); + ResetDirKeyData(); + } + break; + + + // Selection + case EStdKeyEnter: + case EKeyEnter: + case EStdKeyDevice3: //rocker selection key + if (aType == EEventKey) + { + HandleDrawingModeSwitch(iDrawFunction); + } + ResetZoomKeys(); + ResetDirKeyData(); + break; + + default: + // Unknown key, it was not consumed + ret = EKeyWasNotConsumed; + ResetZoomKeys(); + ResetDirKeyData(); + break; + } + } + + DrawNow(); + + return ret; + } + +void CImagicContainerBrowser::HandleDrawingModeSwitch(TDrawFunction& aDrawFunction) + { + //EGrid + if(aDrawFunction == EGrid) + { + //Open one by one mode + iDrawOneByOne->InitDrawOnebyOne(KInitDrawZoom/*drawZoom*/, inPictureX, inPictureY); + + //Set Grid view + if(aDrawFunction == EFaceBrowser) + SetDrawMode(EGrid); + //aDrawFunction = EGrid; + + iView->SetFaceBrowsingMode(EFaceBrowserNone); + } + + //EOneByOne + else if(aDrawFunction == EOneByOne) + { + if(IS_NOT_IN_ZOOM_ONEBYONE) + { + //Return to previous mode + iDrawGrid->InitDrawGrid(); + //aDrawFunction = EGrid; + SetDrawMode(EGrid); + iView->SetFaceBrowsingMode(EFaceBrowserNone); + } + else + { + iDrawOneByOne->SetDrawOneByOneTargetZoom(1); + } + + } + + //EFaceBrowser + else if(aDrawFunction == EFaceBrowser) + { + SetDrawMode(EOneByOne); + //aDrawFunction = EOneByOne; + iDrawOneByOne->InitDrawOnebyOne(/*KInitDrawZoom*/drawZoom, inPictureX, inPictureY); + iView->SetFaceBrowsingMode(EFaceBrowserNone); + } + } + +void CImagicContainerBrowser::SetFullScreen() + { + SetExtentToWholeScreen(); + } + +void CImagicContainerBrowser::HandleRotation(float& aRotationAngle, float& aTargetRotationAngle) + { + // Force target to be in steps of 90 + aTargetRotationAngle=((int)(aTargetRotationAngle/90))*90; + + // Force both angles to be between 0-360 + while (aRotationAngle<0) aRotationAngle+=360; + while (aRotationAngle>360) aRotationAngle-=360; + while (aTargetRotationAngle<0) aTargetRotationAngle+=360; + while (aTargetRotationAngle>360) aTargetRotationAngle-=360; + + // Calculate difference between angles + float diff=aTargetRotationAngle-aRotationAngle; + // Limit difference to be between [-180:180] + while (diff<-180) diff+=360; + while (diff>180) diff-=360; + + // Copy paste from Interpolate, just uses diff calculated above + float aStep=0.26; + float timediff = Min(0.1f, iTimeDiff); // so max value of timediff is 100tick (100ms) + aRotationAngle += diff * aStep * timediff * 30; + + // Calculate new difference + float newDiff=aTargetRotationAngle-aRotationAngle; + while (newDiff<-180) newDiff+=360; + while (newDiff>180) newDiff-=360; + // If difference-angles have different signs, then we went past the target angle + if (diff*newDiff < 0) + aRotationAngle = aTargetRotationAngle; + } + +TBool CImagicContainerBrowser::IsOpenGLInit() + { + return iOpenGlInitialized; + } + +//Disables display drawing +void CImagicContainerBrowser::EnableDisplayDraw() + { + DP0_IMAGIC(_L("CImagicContainerBrowser::EnableDisplayDraw++")); + + if(!iPeriodic->IsActive()) + iPeriodic->Start( 1, iDisplayDrawFreq, TCallBack( CImagicContainerBrowser::DrawCallBackL, this ) ); + + DP0_IMAGIC(_L("CImagicContainerBrowser::EnableDisplayDraw--")); + } + +//Enables display drawing +void CImagicContainerBrowser::DisableDisplayDraw() + { + DP0_IMAGIC(_L("CImagicContainerBrowser::DisableDisplayDraw++")); + + if(iPeriodic) + if(iPeriodic->IsActive()) + { + iPeriodic->Cancel(); + //Clear buffers + //glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + } + + DP0_IMAGIC(_L("CImagicContainerBrowser::DisableDisplayDraw--")); + } + +void CImagicContainerBrowser::SetDrawMode(TDrawFunction aDrawFunction) + { + DP0_IMAGIC(_L("CImagicContainerBrowser::SetDrawMode++")); + + ResetZoomKeys(); + ResetDirKeyData(); + + if(/*aDrawFunction == EOneByOne && */!IS_NOT_IN_ZOOM_ONEBYONE) + { + iDrawOneByOne->SetDrawOneByOneTargetZoom(1); + } + else + { + iDrawFunction = aDrawFunction; + } + + if(aDrawFunction == EGrid) + { + iPreferHighResLoading = EFalse; +#ifdef SUPERZOOM + iIEngine->CancelFullSizeLoading(); + + //Unload high res textures when going back to Grid + CImageData* aGridData = iIEngine->GetImageData(iCurrentIndex); + iTextureLoader->ReleaseSuperHResTexture( aGridData ); +#endif + iDrawGrid->InitDrawGrid(); + } + + DrawNow(); + + DP0_IMAGIC(_L("CImagicContainerBrowser::SetDrawMode--")); + } + +CImagicContainerBrowser::TDrawFunction CImagicContainerBrowser::GetDrawMode() + { + return iDrawFunction; + } + + +void CImagicContainerBrowser::SetBGPSStatus(TBool aValue) + { + //False = BGPS is running + //True = BGPS is completed + iTNCreationComplete = aValue; + } + +CTextureLoader* CImagicContainerBrowser::GetTextureLoader() + { + return iTextureLoader; + } + +float CImagicContainerBrowser::GetAspectRatio(TInt aIndex) + { + return iIEngine->GetImageData(aIndex)->GetAspectRatio(); + } + +void CImagicContainerBrowser::SetFaceCoords(RArray& aCoordinates) + { + iDrawFaceBrowsing->SetFaceCoords(aCoordinates); + } + +void CImagicContainerBrowser::ClearFaceArray() + { + iDrawFaceBrowsing->ClearFaceArray(); + } + +void CImagicContainerBrowser::SetTextIndex(GLuint aIndex) + { + iCurrentBindedIndex = aIndex; + } + +#ifdef _ACCELEROMETER_SUPPORTED_ + +TImagicDeviceOrientation CImagicContainerBrowser::GetDeviceOrientation() + { + return iDeviceOrientation; + } + + +void CImagicContainerBrowser::PhoneRotated(TImagicDeviceOrientation aDeviceOrientation) + { + /*if(iDeviceOrientation == aDeviceOrientation) + { + return; + }*/ + + iDeviceOrientation = aDeviceOrientation; + + //iDrawGridZoom = KZoomOutMaxGrid;//Set initial zooming value when draving Grid +#ifdef ENABLE_GRID_ZOOM +#ifdef ZOOM_WHILE_ROTATING + if(iDrawFunction == EGrid) + iDrawGridTargetZoom = KZoomOutMaxGrid; +#endif +#endif + + if(iDrawFunction == EOneByOne) + { + //Set currect rotation angle immeadetly to target, except for current image index + TInt num = iIEngine->GetTotalNumOfImages(); + for(TInt i=0; i < num; i++ ) + { + if(i != iCurrentIndex) + { + CImageData* data = iIEngine->GetImageData(i); + data->iGridData.iRotationAngle = data->iGridData.iTargetRotationAngle; + } + } + } + else if(iDrawFunction == EFaceBrowser) + { + //Do nothing + } + else if(iDrawFunction == EGrid) + { + //Do nothing + } + + //DrawScreen(); + DrawNow(); + } + +#endif + +void CImagicContainerBrowser::IconTexturesLoaded(RArray aIconTextureIndexes) + { + for(TInt i=0; iCancelFullSizeLoading(); + /* + //Delete OpenGL memory allocations + TInt num = iIEngine->GetTotalNumOfImages(); + for(TInt i=0; i < num; i++ ) + { + CImageData* data = iIEngine->GetImageData(i); + + if(data->iGridData.iGlHQ512TextIndex != 0) + glDeleteTextures(1, &data->iGridData.iGlHQ512TextIndex); + if(data->iGridData.iGlSuperHQTextIndex != 0) + glDeleteTextures(1, &data->iGridData.iGlSuperHQTextIndex); + + data->iGridData.iGlHQ512TextIndex = 0; + data->iGridData.iGlSuperHQTextIndex = 0; + } + */ + + //Delete OpenGL memory allocations + TInt num = iIEngine->GetTotalNumOfImages(); + for(TInt i=0; i < num; i++ ) + { + CImageData* data = iIEngine->GetImageData(i); + + if(data->iGridData.iGlLQ128TextIndex) + glDeleteTextures( 1, &data->iGridData.iGlLQ128TextIndex ); + if(data->iGridData.iGlLQ32TextIndex) + glDeleteTextures( 1, &data->iGridData.iGlLQ32TextIndex ); + if(data->iGridData.iGlHQ512TextIndex != 0) + glDeleteTextures(1, &data->iGridData.iGlHQ512TextIndex); + if(data->iGridData.iGlSuperHQTextIndex != 0) + glDeleteTextures(1, &data->iGridData.iGlSuperHQTextIndex); + + data->iGridData.iGlLQ32TextIndex = 0; + data->iGridData.iGlLQ128TextIndex = 0; + data->iGridData.iGlHQ512TextIndex = 0; + data->iGridData.iGlSuperHQTextIndex = 0; + } + + + DP0_IMAGIC(_L("CImagicContainerBrowser::HandleSend2BackgroundEvent--")); + + } + + +/* +void CImagicContainerBrowser::MrccatoCommand(TRemConCoreApiOperationId aOperationId, TRemConCoreApiButtonAction aButtonAct) + { + TBool pressValue=EFalse; + + switch(aOperationId) + { + case ERemConCoreApiVolumeDown: + { + //do your own stuff + iKeyData.iZoom-=1; + iKeyData.iZoomOut=ETrue; + break; + } + case ERemConCoreApiVolumeUp: + { + //do your own stuff + iKeyData.iZoom+=1; + iKeyData.iZoomIn=ETrue; + break; + } + } + + } + */ + + +TBool CImagicContainerBrowser::GetSlideByDragValue() + { + return iOneByOneSlideByDrag; + } + +TInt CImagicContainerBrowser::GetCurrentIndex() + { + return iCurrentIndex; + } + +TInt CImagicContainerBrowser::GetPrevIndex() + { + return iPreviousIndex; + } + +void CImagicContainerBrowser::SetCurrentIndex(TInt aIndex) + { + CheckIndexLimits(aIndex); + iCurrentIndex = aIndex; + } + +void CImagicContainerBrowser::CheckIndexLimits(TInt &aIndex) + { + //Check that current index is in grid area + TInt num = iIEngine->GetTotalNumOfImages(); + + if(!iJumpOver) + { + if(aIndex >= num) + { + aIndex = num-1; + iIntheEndOfGrid=ETrue; + } + if(aIndex < 0) + { + aIndex = 0; + iIntheEndOfGrid=ETrue; + } + } + else//if(iJumpOver) + { + if (num) + { + aIndex %= num; + if (aIndex < 0) + aIndex = num + aIndex; + } + } + } + +void CImagicContainerBrowser::SetPrevIndex(TInt aIndex) + { + iPreviousIndex = aIndex; + } + + +CKeyData& CImagicContainerBrowser::GetKeyData() + { + return iKeyData; + } + +void CImagicContainerBrowser::SetKeyData(CKeyData aData) + { + iKeyData = aData; + } + +void CImagicContainerBrowser::ResetKeyData() + { + iKeyData.iRotate=0; + + iKeyData.iX=0; + iKeyData.iY=0; + } + +void CImagicContainerBrowser::ResetDirKeyData() + { + iKeyData.iUp=0; + iKeyData.iDown=0; + iKeyData.iLeft=0; + iKeyData.iRight=0; + } + +CKeyData& CImagicContainerBrowser::GetTouchData() + { + return iTouchMoveData; + } + +void CImagicContainerBrowser::SetTouchData(CKeyData aData) + { + iTouchMoveData = aData; + } + +void CImagicContainerBrowser::ResetTouchData() + { + iTouchMoveData.iRotate=0; + iTouchMoveData.iX=0; + iTouchMoveData.iY=0; + iTouchMoveData.iZoomInKey=0; + iTouchMoveData.iZoomOutKey=0; + iTouchMoveData.iRight = EFalse; + iTouchMoveData.iLeft = EFalse; + iTouchMoveData.iUp = EFalse; + iTouchMoveData.iDown = EFalse; + } + + +TInt CImagicContainerBrowser::GetGleMaxRes() + { + return iGLMaxRes; + } + +TBool CImagicContainerBrowser::IsUserInputGiven() + { + return iUserInputGiven; + } + + +TSize CImagicContainerBrowser::GetScreenSize() + { + return iScreenSize; + } + + +// End of File