/*

* Copyright (c) 2008-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:

*

* Description:    Implementation of CGlxZoomControl

*

*/

// INCLUDE FILES

#include "glxzoomcontrol.h"

// INCLUDES

#include <data_caging_path_literals.hrh>

#include <eikbtgpc.h>                       //For CEikButtonGroupContainer

#include <ExifRead.h>

//Alf Headers

#include <alf/alfviewportlayout.h>          //  For CAlfViewPortLayout

#include <alf/alfimagevisual.h>             //  For CAlfImageVisual

#include <alf/alfcontrolgroup.h>            //  For CAlfControlGroup

#include <alf/alfdisplay.h>                 //  For CAlfDisplay

#include <alf/alfroster.h>                  //  For CAlfRoster

#include <alf/alfutil.h>                    //  For AlfUtil

// Antariksh

#include <mul/imulsliderwidget.h>           //  For Slider Widget

#include <mul/mulevent.h>                   //  For Slider events

#include <gesturehelper.h>

#include <e32math.h>

using namespace GestureHelper;

//Gallery Headers

#include <glxuiutility.h>

#include <glxattributecontext.h>

#include <glxtracer.h>                      //  For Tracer

#include <glxlog.h>                         //  For Log

#include <glxtexturemanager.h>              //  For Creating Texture

#include <glxuistd.h>                       //  For Fetch Context Priority

#include <mglxmedialist.h>                  //  For MGlxMediaList

#include <mglxuicommandhandler.h>           //  For MGlxUiCommandHandler

#include "glxtv.h"                          // for CGlxTv

// LOCAL CONSTANTS AND MACROS

const TReal KGlxOpacityOpaque = 1.0;

const TInt KGlxMaxExifSize = 0x10000;   

const TReal KGlxOpacityTransparent = 0.0;

//zoom delay for animation while hdmi cable,

//is connected and zoom is initiated

const TInt KHDMIZoomDelay = 250000; 

//Zoom level for the animation , assuming the innitial level is 1.

const TReal KGlxZoomLevel = 1.5;

const TInt KGlxDecodingThreshold = 3000000; // pixels

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// CGlxZoomControl::CGlxZoomControl

// C++ default constructor can NOT contain any code, that might leave.

// -----------------------------------------------------------------------------

//

CGlxZoomControl::CGlxZoomControl(MGlxUiCommandHandler& aCommandHandler,

        MGlxMediaList& aMediaList,CEikButtonGroupContainer& aZoomBackKeys,

        IMulSliderWidget& aSliderWidget, GestureHelper::CGestureHelper* aGestureHelper) :

        iMediaList(aMediaList), iGestureHelper(aGestureHelper),

        iZoomSliderWidget(aSliderWidget), iZoomBackKey(&aZoomBackKeys), 

        iCommandHandler(aCommandHandler)

    {

    TRACER("CGlxZoomControl::CGlxZoomControl");

    }

// -----------------------------------------------------------------------------

// CGlxZoomControl::ConstructL

// Symbian 2nd phase constructor can leave.

// -----------------------------------------------------------------------------

//

void CGlxZoomControl::ConstructL()

    {

    TRACER("CGlxZoomControl::ConstructL()");

    iAttributeContext = CGlxDefaultAttributeContext::NewL();

    iAttributeContext->AddAttributeL(KGlxMediaGeneralDimensions);

    iMediaList.AddContextL( iAttributeContext, KGlxFetchContextPriorityLow );

    iUiUtility = CGlxUiUtility::UtilityL();

    iEnv = iUiUtility->Env();

    iDisplay = iUiUtility->Display();

    iTextureMgr = &iUiUtility->GlxTextureManager();

    iScreenSize = ScreenSize();

    iDisplay->SetVisibleArea(TRect(TPoint(0,0),iScreenSize));

    CAlfControl::ConstructL(*iEnv);

    //Func creating black background and visual that has to zoomed     

    CreateZoomVisualL();

    iControlGroup = &iEnv->NewControlGroupL(0x119);

    iControlGroup->AppendL(this);

    iDisplay->Roster().ShowL( *iControlGroup);

    // Hide the Zoom at the construction

    ShowZoom(EFalse);

    iZoomActive = EFalse;

    //To know if HDMi cable is connected.

    iGlxTvOut = CGlxTv::NewL(*this);

    iTimer = CPeriodic::NewL( CActive::EPriorityStandard );

    iGPUMemMonitor = CGlxRelaseGPUMemory::NewL(*this);

    }

// -----------------------------------------------------------------------------

// ScreenSize : gets the screensize, Note that , this is not stored in member variable as

// Screen rect can change based on orientation

// -----------------------------------------------------------------------------

//

TSize CGlxZoomControl::ScreenSize()

    {

    TRACER("CGlxZoomControl::ScreenSize()");

    return AlfUtil::ScreenSize();

    }

// -----------------------------------------------------------------------------

// ShowZoom

// -----------------------------------------------------------------------------

//    

void CGlxZoomControl::ShowZoom(TBool aShow)

    {

    TRACER("CGlxZoomControl::ShowZoom()");

    if (aShow)

        {

        iViewPort->SetOpacity(KGlxOpacityOpaque);

        iGestureHelper->AddObserver(this);

        }

    else

        {

        iViewPort->SetOpacity(KGlxOpacityTransparent);

        }

    }

// -----------------------------------------------------------------------------

// CreateZoomVisual

// -----------------------------------------------------------------------------

//    

void CGlxZoomControl::CreateZoomVisualL()

    {

    TRACER("CGlxZoomControl::CreateZoomVisualL()");

    CAlfTexture *blackoutTexture = &(iTextureMgr->CreateFlatColourTextureL(KRgbBlack));

    CleanupStack::PushL(blackoutTexture);

    iViewPort = CAlfViewportLayout::AddNewL(*this);

    //Create the Image visual ,which holds the texture,which is complete black in color

    CAlfImageVisual *blackoutImageVisual = CAlfImageVisual::AddNewL(*this,iViewPort);

    CleanupStack::PushL(blackoutImageVisual);

    // Visual is larger than the screen to deal with control transformations that

    // may show areas usually outside the normal screen coordinates

    TInt16 blackImageSize =(iScreenSize.iWidth > iScreenSize.iHeight) ?iScreenSize.iWidth:iScreenSize.iHeight;

    blackoutImageVisual->SetImage(TAlfImage(*blackoutTexture));

    blackoutImageVisual->SetFlag(EAlfVisualFlagManualLayout);

    blackoutImageVisual->SetSize(TAlfRealSize(blackImageSize, blackImageSize));

    blackoutImageVisual->SetPos(TAlfRealPoint(0, 0));

    CleanupStack::Pop(blackoutImageVisual);

    CleanupStack::Pop(blackoutTexture);

    //  VisualLayoutUpdated

    //  Enable scrolling of the Viewport.

    //  The content area of a layout can be thought to be larger than the real visible size. 

    //  Scrolling changes which portion of the layout’s content is actually visible at  the moment.

    iViewPort->SetFlag(EAlfVisualFlagLayoutUpdateNotification);

    iViewPort->SetVirtualSize(TAlfRealSize(iScreenSize.iWidth,iScreenSize.iHeight), 0);

    iViewPort->SetViewportSize(TAlfRealSize(iScreenSize.iWidth,iScreenSize.iHeight), 0);

    iViewPort->SetViewportPos(TAlfRealPoint(0,0), 0);

    iViewPort->SetClipping(EFalse);

    iViewPort->SetOrigin( EAlfVisualHOriginLeft, EAlfVisualVOriginTop );

    //Enable scrolling of the Viewport.

    //The content area of a layout can be thought to be larger than the real visible size. 

    //Scrolling changes which portion of the layout’s content is actually visible at  the moment.

    iViewPort->EnableScrollingL();

    iViewPort->EnableTransformationL();

    iImageVisual = CAlfImageVisual::AddNewL(*this,iViewPort);

    iImageVisual->SetScaleMode(CAlfImageVisual::EScaleFitInside);

    iEventHandler = CGlxZoomPanEventHandler::NewL(*this);

    }

// -----------------------------------------------------------------------------

// CGlxZoomControl::NewL

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

EXPORT_C CGlxZoomControl* CGlxZoomControl::NewL(

        MGlxUiCommandHandler& aCommandHandler,

        MGlxMediaList& aMediaList,CEikButtonGroupContainer& aZoomKeys,

        IMulSliderWidget& aSliderWidget, GestureHelper::CGestureHelper* aGestureHelper)

    {

    TRACER("CGlxZoomControl::NewL");

    CGlxZoomControl* self = new (ELeave) CGlxZoomControl(aCommandHandler,

            aMediaList,aZoomKeys,aSliderWidget,aGestureHelper);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

// -----------------------------------------------------------------------------

// Destructor

// -----------------------------------------------------------------------------

//

CGlxZoomControl::~CGlxZoomControl()

    {

    TRACER("CGlxZoomControl::~CGlxZoomControl()");

    if(iTimer->IsActive())

        {

        iTimer->Cancel();

        }

    delete iTimer;

    if(iGPUMemMonitor)

        {

        delete iGPUMemMonitor;

        }

    if(iGlxTvOut)

        {

        delete iGlxTvOut;

        }

    if(iEventHandler)

        {

        delete iEventHandler;

        iEventHandler = NULL ;

        }

    if(iViewPort)

        {

        iViewPort->RemoveAndDestroyAllD();

        iViewPort = NULL;

        }

    iMediaList.RemoveContext(iAttributeContext);

    delete iAttributeContext;

    if(iImageTexture)

        {

        delete iImageTexture;

        iImageTexture=NULL;

        }

    iDisplay->Roster().Hide(*iControlGroup);

    if ( iControlGroup )

        {

        iControlGroup->Remove(this);

        iEnv->DeleteControlGroup(0x119);

        iControlGroup = NULL;

        }

    if ( iUiUtility )

        {

        iUiUtility->Close();

        }

    }

// -----------------------------------------------------------------------------

// ActivateL:Activates the Zoom Control,set the image visual ,do the initial setup

// -----------------------------------------------------------------------------

//

EXPORT_C void CGlxZoomControl::ActivateL(TInt aInitialZoomRatio, TZoomStartMode aStartMode, 

        TInt aFocusIndex, TGlxMedia& aItem, TPoint* aZoomFocus,TBool aViewingMode)

    {

    TRACER("CGlxZoomControl::ActivateL()");

    //Request to release GPU mem parallelly

    iGPUMemMonitor->RequestMemory(EFalse);

    if ( !iZoomActive )

        {

        //To Retrive the image details

        TMPXAttribute thumbNailAttribute(0,0);

        TGlxIdSpaceId idspace = iMediaList.IdSpaceId( aFocusIndex );

        //Get the texture Created in fullscreen View.

        iImageTexture = &(iTextureMgr->CreateNewTextureForMediaL(

                ScreenSize(),aItem, idspace, this ));

        iImageVisual->SetImage(*iImageTexture);

        if(iGlxTvOut->IsHDMIConnected()&& !aViewingMode )

            {

            StartZoomAnimation(aStartMode);

            }

        else

            {

            ShowZoom(ETrue);

            iZoomSliderWidget.AddEventHandler(*this);

            iZoomSliderWidget.SetHandleKeyEvent(EFalse);

            iZoomSliderModel = (IMulSliderModel*) iZoomSliderWidget.model();

            if(iZoomSliderWidget.IsHidden())

                {

                iEventHandler->SetZoomUiState(EUiOff);

                }

            else

                {

                iEventHandler->SetZoomUiState(EUiOn);

                }

            // Get size, return value tells us if it was available

            //We need this Value to calculate the size of the visual/Layout corresponding to the Zoom factor

            TSize imageSize;

            aItem.GetDimensions( imageSize );

            TSize maxVirtualImageSize = imageSize;

            if (KGlxDecodingThreshold < (imageSize.iWidth * imageSize.iHeight))

                {

                TReal areaRatio = TReal(imageSize.iWidth*imageSize.iHeight)/KGlxDecodingThreshold ;

                TReal sideRatio;

                Math::Sqrt(sideRatio, areaRatio);

                maxVirtualImageSize.iHeight = imageSize.iHeight /  sideRatio ;

                maxVirtualImageSize.iWidth  = imageSize.iWidth  /  sideRatio ;

                }

            // Now since our maximum size possible is 3 MP. all our zoom percentages will be relative to it. 

            // So our initial zoom ratio will be different and cnsequently our minimum slider value too will change. 

            GLX_LOG_INFO1("ActivateZoomControlL: Slider MaxRange = %d   ", iZoomSliderModel->MaxRange() );

            GLX_LOG_INFO1("ActivateZoomControlL: Slider MinRange = %d   ", iZoomSliderModel->MinRange() );

            GLX_LOG_INFO1("ActivateZoomControlL: Slider PrimaryValue= %d", iZoomSliderModel->PrimaryValue() );

            iEventHandler->SetZoomActivated(ETrue);

            if (aStartMode == EZoomStartSlider) 

                {

                iEventHandler->ActivateZoom(aInitialZoomRatio,

                        maxVirtualImageSize,

                        aStartMode,

                        iZoomSliderModel->MinRange(), 

                        iZoomSliderModel->MaxRange(),

                        aZoomFocus);

                }

            else 

                {

                iEventHandler->ActivateZoom(aInitialZoomRatio,

                        maxVirtualImageSize,

                        aStartMode,

                        iZoomSliderModel->MinRange(), 

                        iZoomSliderModel->MaxRange(),

                        aZoomFocus);

                }

            TRAP_IGNORE(iImageTexture = 

            &(iTextureMgr->CreateZoomedTextureL(aItem,thumbNailAttribute,idspace,this)));

            //This is for handling the alaram interrupt events,that causes the phone to freeze.

            CEikButtonGroupContainer* cba = CEikButtonGroupContainer::Current();

            if (NULL != cba)

                {

                if (cba->IsVisible())

                    {

                    cba->ActivateL();

                    }

                }

            }

        // Now the zoom activation process is complete.

        // Now is when truly zoom is active. 

        iZoomActive = ETrue;

        }

    }

// ---------------------------------------------------------------------------

// StartZoomAnimation

// ---------------------------------------------------------------------------

// 

void CGlxZoomControl::StartZoomAnimation(TZoomStartMode aStartMode)

    {

    TRACER("CGlxZoomControl::StartZoomAnimation()");

    iZoomIn = ETrue;

    //Set zoom visible but not enable the gesturehelper events    

    iViewPort->SetOpacity(KGlxOpacityOpaque);    

    TAlfTimedValue timedvalue;

    //using KGlxOpacityOpaque for the value 1 , assuming the initial zoom level as 1.

    timedvalue.SetValueNow(KGlxOpacityOpaque); 

    timedvalue.SetTarget(KGlxZoomLevel,KHDMIZoomDelay/1000);    

    iImageVisual->SetScale(timedvalue);

    //If zoom is not done using pinch, zoom out with the rubber effect

    //Else wait for the gesture helper event for zooming out.

    if(aStartMode != EZoomStartPinch)

        {

        iTimer->Cancel();

        iTimer->Start(KHDMIZoomDelay,KHDMIZoomDelay,TCallBack( TimeOut,this ));

        }

    else

        {

        iGestureHelper->AddObserver(this);

        }

    }

// ---------------------------------------------------------------------------

// TimeOut

// ---------------------------------------------------------------------------

//  

TInt CGlxZoomControl::TimeOut(TAny* aSelf)

    {

    TRACER("CGlxZoomControl::TimeOut");

    if(aSelf)

        {

        CGlxZoomControl* self = static_cast <CGlxZoomControl*> (aSelf);

        self->ActivateFullscreen();            

        }

    return KErrNone;

    }

// ---------------------------------------------------------------------------

// ActivateZoomAnimation

// ---------------------------------------------------------------------------

//

void CGlxZoomControl::ActivateFullscreen()

    {

    TRACER("CGlxZoomControl::ActivateFullscreen");

    if(iZoomIn)

        {

        iZoomIn = EFalse;

        TAlfTimedValue timedvalue;

        timedvalue.SetValueNow(KGlxZoomLevel);

        timedvalue.SetTarget(KGlxOpacityOpaque,KHDMIZoomDelay/1000);

        iImageVisual->SetScale(timedvalue);

        }

    else

        {

        if(iTimer->IsActive())

          {

          iTimer->Cancel();

          }

        //once the animation  is done come back to fullscreen.

        HandleZoomOutL(KGlxZoomOutCommand);

        }

    }

// -----------------------------------------------------------------------------------

// Deactivate:Remove the screen furniture ,cancel the timers if any

// ----------------------------------------------------------------------------------

//

EXPORT_C void CGlxZoomControl::Deactivate()

    {

    TRACER("CGlxZoomControl::Deactivate()");

    if (iZoomActive)

        {

        if (iTimer->IsActive())

            {

            iTimer->Cancel();

            }

        iZoomSliderWidget.RemoveEventHandler(*this);

        iZoomBackKey->MakeVisible(EFalse);

        iTextureMgr->RemoveZoomList();

        iImageVisual->SetImage(*iImageTexture);

        iEventHandler->DeactivateZoom();

        CleanUpVisual();

        iZoomActive = EFalse;

        iEventHandler->SetZoomActivated(EFalse);

        }

    // Hide the Zoom View

    ShowZoom(EFalse);

    } 

// -----------------------------------------------------------------------------------

// HandleZoomForegroundEventL:Zoom Foreground event handling function

// ----------------------------------------------------------------------------------

//

EXPORT_C void CGlxZoomControl::HandleZoomForegroundEvent(TBool aForeground)

    {

    TRACER("CGlxZoomControl::HandleZoomForegroundEventL()");

    if (!aForeground)

        {

        ShowUi(EFalse);

        iEventHandler->CancelZoomPanTimer();

        iEventHandler->CancelUITimer();

        iEventHandler->CancelAnimationTimer();

        }

    else

        {

        iGPUMemMonitor->RequestMemory();

        }

    } 

// -----------------------------------------------------------------------------

// CleanUpVisual:reset the values of the variables.

// -----------------------------------------------------------------------------

//

void CGlxZoomControl::CleanUpVisual()

    {

    TRACER("CGlxZoomControl::CleanUpVisual() ");

    }

// -----------------------------------------------------------------------------

// Activated

// -----------------------------------------------------------------------------

//

EXPORT_C TBool CGlxZoomControl::Activated()

    {

    TRACER("CGlxZoomControl::Activated");

    return iZoomActive;

    }

// -----------------------------------------------------------------------------

// OfferEventL

// -----------------------------------------------------------------------------

//

TBool CGlxZoomControl::OfferEventL(const TAlfEvent &aEvent)

    {

    TRACER("CGlxZoomControl::OfferEventL()");

    GLX_LOG_INFO1("OfferEventL 2: iZoomEnabled = %d   ", iZoomActive );

    // All the events related to the keys and pointers will be coming to this offerevent

    return iEventHandler->HandleEventL(aEvent) ;

    }