/*

* 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 <e32math.h>

#include <e32debug.h>

#include <BitmapTransforms.h> 

#include <e32cmn.h>

#include <hal.h>

#include "Imagic.hrh"

#include "project.h"

#include <hal.h>

#include "DrawUtility.h"

#include "ImagicConsts.h"

#include <PhotoBrowser.rsg>

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;

   }