/*

* 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 fULL-SCREEN view

*

*/

// Avkon and System Headers 

#include <eikbtgpc.h>                           // CEikButtonGroupContainer

#include <aknViewAppUi.h>

#include <data_caging_path_literals.hrh>        // for KDC_APP_RESOURCE_DIR

#include <glxcollectionpluginimageviewer.hrh>

#include <StringLoader.h>                       // String Loader

// Alf Headers

#include <alf/ialfwidgetfactory.h>              // widget factory

#include <alf/alfwidgetcontrol.h>               // To get CAlfControl from CAlfWidgetControl

#include <alf/ialfviewwidget.h>                 // View Widget

#include <alf/alfwidgetenvextension.h>          // Widget Env Extensions to create view widget

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

// Antariksh Headers

#include <mul/mulevent.h>

#include <mul/imulcoverflowwidget.h>            // Coverflow widget

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

#include <mpxcollectionpath.h>

#include <gesturehelper.h>

using namespace GestureHelper;

//Hg 

//#include <hg/hgcontextutility.h>

#include <glxhdmicontroller.h>

// Photos Headers

#include <glxlog.h>                             // CGlxLogger

#include <glxtracer.h>                          // For Log

#include <glxmedialistmulmodelprovider.h>       // For MulModelProvider

#include <glxcommandhandlers.hrh>               // For EGlxCmdFullScreenBack               

#include <glxfullscreenviewdata.rsg>            // FS View Resource

#include <glxthumbnailattributeinfo.h>          // KGlxMediaIdThumbnail

//#include "glxmediakeyutility.h"

#include <glxactivemedialistregistry.h>         // For medialist registry

#include <glxerrormanager.h>

#include <glxzoomcontrol.h>

#include <glxuiutilities.rsg>

#include <glxgeneraluiutilities.h>

#include <glxtexturemanager.h>

#include <glxicons.mbg>

#include <glxsetappstate.h>

#include <glxdrmutility.h>

#include <glxscreenfurniture.h>

//#include <glxsinglelinemetapanecontrol.h>

#include "glxfullscreenviewimp.h"

#include <glxnavigationalstate.h>

using namespace Alf;

//To disable AppUi status pane

#define GetAppViewUi() (dynamic_cast<CAknViewAppUi*>(CEikonEnv::Static()->EikAppUi()))

const TInt KGlxScreenTimeout =10000000;

const TInt KCoverflowDataWindowSize = 1;

const TInt KGlxRotationDelay = 800;    // Milliseconds

const TInt KGlxMaxSmallImageZoomLevel =150;

const TInt KGlxMaxBigImageZoomLevel   =100;

const TInt KGlxMinSmallImageZoomLevel =100;

const TInt KGlxNeutralPinchPosition   =100;

const TInt KGlxSliderTickValue        =5;

_LIT(KGlxIconsFilename, "glxicons.mif");

/**

 * Start Delay for the periodic timer, in microseconds

 */

const TInt KPeriodicStartDelay = 250000; 

//This constant is used to calculate the index of the item for which texture has to removed.

//6 = 5(iterator value in forward or backward direction for fullscreen) + 1(focus index);

const TInt KFullScreenIterator = 3; 

//Constant which says maximum number of fullscreen textures that we have have at a time.

//11 = (5(5 fullscreen texture backwards)+1(fucus index texture)+5(5 fullscreen texture forwards))

const TInt KFullScreenTextureOffset = 5;

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

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

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

// might leave.

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

//

CGlxFullScreenViewImp::CGlxFullScreenViewImp(

		const TFullScreenViewResourceIds& aResourceIds, TInt aViewUID) :

	iResourceIds(aResourceIds), iViewUid(aViewUID)

	{

	TRACER("CGlxFullScreenViewImp::CGlxFullScreenViewImp");

	}

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

// Two-phased constructor.

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

//

CGlxFullScreenViewImp* CGlxFullScreenViewImp::NewL(

		MGlxMediaListFactory* aMediaListFactory,

		const TFullScreenViewResourceIds& aResourceIds, 

		TInt aViewUID,

		const TDesC& aTitle)

	{

	TRACER("CGlxFullScreenViewImp::NewL");

	CGlxFullScreenViewImp* self = CGlxFullScreenViewImp::NewLC (

			aMediaListFactory, aResourceIds, aViewUID, aTitle);

	CleanupStack::Pop (self);

	return self;

	}

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

// Two-phased constructor.

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

//

CGlxFullScreenViewImp* CGlxFullScreenViewImp::NewLC(

		MGlxMediaListFactory* aMediaListFactory,

		const TFullScreenViewResourceIds& aResourceIds, TInt aViewUID,

		const TDesC& aTitle)

	{

	TRACER("CGlxFullScreenViewImp::NewLC");

	CGlxFullScreenViewImp* self =new (ELeave) CGlxFullScreenViewImp(aResourceIds, aViewUID);

	CleanupStack::PushL (self);

	self->ConstructL (aMediaListFactory, aTitle);

	return self;

	}

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

//  ConstructL.

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

//

void  CGlxFullScreenViewImp::ConstructL(

		MGlxMediaListFactory* aMediaListFactory, const TDesC& aTitle)

	{

	TRACER("CGlxFullScreenViewImp::ConstructL");

	BaseConstructL (iResourceIds.iViewId);

	ViewBaseConstructL();

	MLViewBaseConstructL (aMediaListFactory, aTitle , EFalse);

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

	//Register the view to recieve toolbar events. ViewBase handles the events

	SetToolbarObserver(this);

	// Presently image viewer dont have toolbar

	// So need to remove if image viewer using full screen

	CGlxNavigationalState* navigationalState =  CGlxNavigationalState::InstanceL();

	CleanupClosePushL( *navigationalState );

	CMPXCollectionPath* naviState = navigationalState->StateLC();

	if (naviState->Id() == TMPXItemId(KGlxCollectionPluginImageViewerImplementationUid))

	    {

	    CAknToolbar* toolbar = Toolbar();

	    if(toolbar)

	        {

	        toolbar->DisableToolbarL(ETrue);

	        }

	    ShowToolbarOnViewActivation(EFalse);

	    }

	else

	    {

	    ShowToolbarOnViewActivation(ETrue);

	    }

	CleanupStack::PopAndDestroy(naviState);

	CleanupStack::PopAndDestroy(navigationalState);

	//Get the ScreenFurniture instance

	iScreenFurniture = iUiUtility->ScreenFurniture();

    //Get the env from the uiutilities

	iEnv = iUiUtility->Env ();

	iZoomButtonGroup = CEikButtonGroupContainer::NewL(

	        CEikButtonGroupContainer::ECba,  // type

	        CEikButtonGroupContainer::EHorizontal,  // orientation

	        this,  // command observer

	        R_GLX_FULLSCREEN_SOFTKEYS_ZOOM ); 

	iZoomButtonGroup->MakeVisible( EFalse );

	//create the drmutility instance

	iDrmUtility = CGlxDRMUtility::InstanceL();

   // Get object that stores the active media list registry

    iActiveMediaListRegistry = CGlxActiveMediaListRegistry::InstanceL();

    if(!iPeriodic)

		{

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

		}

    }

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

// ~CGlxFullScreenViewImp()

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

//

CGlxFullScreenViewImp::~CGlxFullScreenViewImp()

    {

    TRACER("CGlxFullScreenViewImp::~CGlxFullScreenViewImp");

    delete iMediaListMulModelProvider;   

    if(iTimer->IsActive())

	    {

	    iTimer->Cancel();

	    }

	delete iTimer;   

	if(iZoomButtonGroup)

        {

        AppUi()->RemoveFromStack( iZoomButtonGroup );

        delete iZoomButtonGroup;

        }

    if(iActiveMediaListRegistry)

        {

        iActiveMediaListRegistry->Close();

	    }

    if( iDrmUtility )

		{

		iDrmUtility->Close();

		}

    if (iPeriodic)

 		{

 		iPeriodic->Cancel();

 		delete iPeriodic;

 		}

	}

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

// From CGlxViewBase

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

//

TUid CGlxFullScreenViewImp::Id() const

    {

    TRACER("CGlxFullScreenViewImp::Id");

    return TUid::Uid(iViewUid);

	}

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

// Destroys a coverflow widget

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

//

void CGlxFullScreenViewImp::DestroyWidgets()

    {

    TRACER("CGlxFullScreenViewImp::DestroyCoverflowWidget");

    if (iCoverFlowWidget)

        {

        iCoverFlowWidget->RemoveEventHandler(*this);

        }

    // Destror Slider widget

    DestroySliderWidget();

    delete iMediaListMulModelProvider;

    iMediaListMulModelProvider = NULL;

    IAlfWidgetFactory& widgetFactory = AlfWidgetEnvExtension::widgetFactory(*iEnv); 

    // Destroying this widget calls destructor of single line meta pane

    widgetFactory.destroyWidget(iViewWidget);

    iCoverFlowWidget = NULL;

    iViewWidget = NULL;

    }

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

// Destroys a Slider widget

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

//

void CGlxFullScreenViewImp::DestroySliderWidget()

    {

    TRACER("CGlxFullScreenViewImp::DestroySliderWidget");

    if(iSliderWidget)

        {

        iSliderWidget->RemoveEventHandler(*this);

        }

    iSliderWidget = NULL;

    iSliderModel = NULL;

    }

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

// From CAknView

// Handles a view activation.

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

//

void CGlxFullScreenViewImp::DoMLViewActivateL(

		const TVwsViewId & /* aPrevViewId */, TUid /* aCustomMessageId */,

		const TDesC8 & /* aCustomMessage */)

	{

    TRACER("CGlxFullScreenViewImp::DoMLViewActivateL");

    	//Fix For EPKA-7U5DT7-slideshow launched from FullScreen and connect USB in mass storage mode results in Photos crash

	if(!iMediaList->Count())

		{

	  	CGlxNavigationalState* navigationalState =  CGlxNavigationalState::InstanceL();

	  	CleanupClosePushL( *navigationalState );

	  	navigationalState->ActivatePreviousViewL();

	  	CleanupStack::PopAndDestroy( navigationalState );

		}  

	//need to create the instance first,other wise panics while

	// zooming from imgvwr.

	iHdmiController = CGlxHdmiController::NewL();

	if(iMediaList->Count())

	    {

	    iOldFocusIndex = iMediaList->FocusIndex(); 

        TGlxMedia item = iMediaList->Item( iMediaList->FocusIndex() );

        GLX_LOG_INFO("CGlxHdmi - CGlxFullScreenViewImp Create HdmiController");

        if (item.Category() != EMPXVideo)

            {

            TInt frameCount(0);

            TSize orignalSize;

            TBool aFramesPresent  = item.GetFrameCount(frameCount);

            TBool adimension  = item.GetDimensions(orignalSize);

            iHdmiController->SetImageL(item.Uri(), orignalSize, frameCount);

            }    

	    }

    iScreenFurniture->SetActiveView(iViewUid);

    //set the ui state to off,when the Fullscreen launches

    SetUiSate(NGlxNFullScreenUIState::EUiOff);

   	GlxSetAppState::SetState(EGlxInFullScreenView);

    // create the coverflow

    CreateCoverflowWidgetL();

    // create the screen furniture for touch devices

    CreateScreenFurnitureL();

    CreateSliderWidgetL();

//    iMediaKeyUtility = CGlxMediaKeyUtility::NewL();

    // create a zoom control

    iZoomControl = CGlxZoomControl::NewL(*this, *iMediaList,

            *iZoomButtonGroup, *iSliderWidget, iGestureHelper);

    // Create the Metapane

    //iSingleLineMetaPane = CGlxSinleLineMetaPane::NewL(*this,*iMediaList,*iUiUtility);

    // hide the screen furniture

    HideUi(ETrue);

	// Set active media list pointer, so that UPnP renderer knows about this list

    iActiveMediaListRegistry->RegisterActiveMediaList(iMediaList);

    //Get the HgContextUtility instance

//    iContextUtility = iUiUtility->ContextUtility();

    // if the Medialist has any item, set the First index context to Hg Context Utility

//    TGlxMedia item = iMediaList->Item( iMediaList->FocusIndex() );

//    iContextUtility->PublishPhotoContextL(item.Uri());

    	if ( !iPeriodic->IsActive() )

		{

		iPeriodic->Start( KPeriodicStartDelay, KMaxTInt, TCallBack( 

		        &PeriodicCallback, static_cast<TAny*>( this ) ) );

		}

	}

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

// Creates a coverflow widget

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

//

void CGlxFullScreenViewImp::CreateCoverflowWidgetL()

    {

    TRACER("CGlxFullScreenViewImp::CreateCoverflowWidgetL");

    const char* KWidgetName("mulcoverflowwidget");

    const char* KCoverflowViewWidget("CoverflowViewWidget");

    const char* KCoverflowWidget("CoverflowWidget");

    try

        {

        // Get widget factory from CAlfEnv

        // Factory is then used to create the individual widgets & data model

        IAlfWidgetFactory& widgetFactory = AlfWidgetEnvExtension::widgetFactory(*iEnv); 

    // create a view widget  

    iViewWidget = widgetFactory.createViewWidget (

            KCoverflowViewWidget, 0x113);

    // hide control and status pane

    iViewWidget->enableControlPane(EFalse);

    iViewWidget->enableStatusPane(EFalse);

    iViewWidget->setRect(TRect(TPoint(0,0),AlfUtil::ScreenSize()));

    iViewWidget->show(true);

    // create coverflow widget

    iCoverFlowWidget = widgetFactory.createWidget<IMulCoverFlowWidget> (

            KWidgetName, KCoverflowWidget, *iViewWidget, NULL);			

    iCoverFlowWidget->SetFlags(IMulMultiItemWidget::EMulWidgetDoubleTap);

    // Widget takes the ownership

        iCoverFlowWidget->AddEventHandler (*this);

        // hide appui's status pane  

        GetAppViewUi()->StatusPane()->MakeVisible(EFalse);

        // hide appui's softkeys

        GetAppViewUi()->Cba()->MakeVisible(EFalse);

    iCoverFlowWidget->ShowWidget(ETrue);

    iCoverFlowWidget->control()->AcquireFocus();

        iMediaListMulModelProvider = CGlxMediaListMulModelProvider::NewL (*iEnv,

                *iCoverFlowWidget, *iMediaList, iFullScreenBindingSet,

                mulwidget::KTemplate4, KCoverflowDataWindowSize );

        iGestureHelper = (GestureHelper::CGestureHelper*)iCoverFlowWidget->Gesturehelper();

        }

    catch(...)

        {

        User::Leave(KErrGeneral);

        }

    }

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

//Initialise the slider widget and the slider model

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

//

void CGlxFullScreenViewImp::CreateSliderWidgetL()

    {

    const char* KSliderWidgetName("mulsliderwidget");

    const char* KZoomSliderWidget("ZoomSliderWidget");

    try

        {

        IAlfWidgetFactory& widgetFactory = AlfWidgetEnvExtension::widgetFactory(*iEnv);

        iSliderWidget = widgetFactory.createWidget<IMulSliderWidget>( KSliderWidgetName, 

                KZoomSliderWidget, *iViewWidget, NULL);

        iSliderWidget->AddEventHandler(*this);

        iSliderWidget->SetHandleKeyEvent(EFalse);

        iSliderModel = widgetFactory.createModel<IMulSliderModel> ("mulslidermodel");

        iSliderModel->SetTemplate(ESliderTemplate3);

        iSliderWidget->setModel(iSliderModel);

        //adding the range and slider tick value 

        if(iSliderModel)

            {

            iSliderModel->SetTick(KGlxSliderTickValue);

            }

        //SetSliderLevel();

        }

    catch(...)

        {

        User::Leave(KErrGeneral);

        }

    }

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

// ShowUiL

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

//	

void  CGlxFullScreenViewImp::ShowUiL(TBool aStartTimer)

    {

    TRACER("CGlxFullScreenViewImp::ShowUiL");

    TInt index = iMediaList->FocusIndex();

    const TGlxMedia& item = iMediaList->Item(index);

    TInt error = GlxErrorManager::HasAttributeErrorL(item.Properties(), KGlxMediaIdThumbnail);

    // Display slider only for non corrupted images

    if (error == KErrNone && item.Category() == EMPXImage)

        {

        //To set the Slider values.

        SetSliderLevel();

        //show the slider

        iSliderWidget->ShowWidget(ETrue);

        }

    if (iCoverFlowWidget)

        {

		// This is done to set the item counter

        iCoverFlowWidget->SetUIMode(ETrue);

        }

    //show the toolbar

    CAknToolbar* toolbar = Toolbar();

    if(toolbar)

        {

        toolbar->SetToolbarVisibility(ETrue);    

        }

    // For floating toolbar in non-touch devices

    iScreenFurniture->SetToolbarVisibility(ETrue);

    //show the softkeys

    Cba()->MakeVisible( ETrue );

    Cba()->DrawNow();

    // Show the Metapane

    //iSingleLineMetaPane->ShowMetaPane(ETrue);

    //set the ui state to On

    SetUiSate(NGlxNFullScreenUIState::EUiOn);

    //start the timer,for the screen timeout

    iTimer->Cancel();

    if(aStartTimer)

        {

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

        }

    }

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

// HideUi

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

//	

void  CGlxFullScreenViewImp::HideUi(TBool aSliderStatus)

    {

    TRACER("CGlxFullScreenViewImp::HideUi");

    //cancel the timer

    iTimer->Cancel();

    // For floating toolbar in non-touch devices

    iScreenFurniture->SetToolbarVisibility(EFalse);

    // hide the slider

    if(aSliderStatus && iSliderWidget)

        {

   	    iSliderWidget->ShowWidget(EFalse);

		}

    if (iCoverFlowWidget)

        {

        iCoverFlowWidget->SetUIMode(EFalse);