/*

 * 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 Grid view control

 *

 */

#include <AknUtils.h>                               	// For AknLayoutUtils to calculate rect

#include <glxtracer.h>

#include <StringLoader.h>

#include <AknsBasicBackgroundControlContext.h>

#include <caf/caferr.h>

#include <eikcolib.h> 

// Ganes Headers

#include <gulicon.h>                                    // Gul Icons

#include <ganes/HgItem.h>                               // HG Items

#include <ganes/HgGrid.h>                               // Hg Grid Widget

// Framework

#include <data_caging_path_literals.hrh>

#include <glxcommandhandlers.hrh>                       // For EGlxCmdFullScreenBack

#include <glxcollectionpluginall.hrh> 	            	// All item collection plugin id

#include <glxnavigationalstate.h>                       // For Navigational State

#include <mglxmedialist.h>				            	// MGlxMediaList, CMPXCollectionPath

#include <glxuiutility.h>                               // For UiUtility instance

#include <glxdrmutility.h>                              // DRM utility class to provide DRM-related functionality

#include <glxerrormanager.h>                            // For CGlxErrormanager

#include <glxthumbnailattributeinfo.h>                  // KGlxMediaIdThumbnail

#include <glxgridviewdata.rsg>                          // Gridview resource

#include <glxicons.mbg>                                 // For Corrupted and not created icons

#include "glxgridviewcontainer.h"

#include "glxgridviewimp.h"

#include "glxgridviewmlobserver.h"                      // medialist observer for Hg Grid

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

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

// Two-phased constructor.

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

//

CGlxGridViewContainer* CGlxGridViewContainer::NewL(MGlxMediaList *aMediaList,

        CGlxUiUtility* aUiUtility, MGlxGridEventObserver& aObserver,

        CAknToolbar* aToolbar)

    {

    TRACER("CGlxGridViewContainer::NewL");

    CGlxGridViewContainer* self = CGlxGridViewContainer::NewLC(aMediaList,

            aUiUtility, aObserver, aToolbar);

    CleanupStack::Pop(self);

    return self;

    }

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

// Two-phased constructor.

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

//

CGlxGridViewContainer* CGlxGridViewContainer::NewLC(

        MGlxMediaList *aMediaList, CGlxUiUtility* aUiUtility,

        MGlxGridEventObserver& aObserver, CAknToolbar* aToolbar)

    {

    TRACER("CGlxGridViewContainer::NewLC");

    CGlxGridViewContainer* self = new (ELeave) CGlxGridViewContainer(

            aMediaList, aUiUtility, aObserver, aToolbar);

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

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

// Destructor

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

//

CGlxGridViewContainer::~CGlxGridViewContainer()

	{

	TRACER("CGlxGridViewContainer::~CGlxGridViewContainer");	

	delete iMMCNotifier;

	iMMCNotifier = NULL;

	if(iBgContext)

		{

		delete iBgContext;	

		}

	if(iDRMUtility)

		{

		iDRMUtility->Close();

		}

	if (iGlxGridMLObserver)

		{

		delete iGlxGridMLObserver;

		iGlxGridMLObserver = NULL;

		}

	if (iMediaList)

		{

		iMediaList->RemoveContext(iThumbnailContext);

		delete iThumbnailContext;

		}

	if(iNavigationalstate)

		{

		iNavigationalstate->Close();

		}

	if (iHgGrid)

		{

		delete iHgGrid;

		iHgGrid = NULL;

		}

	//reset the flag

	iBackwardActivation = EFalse;

	}

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

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

// might leave.

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

//

CGlxGridViewContainer::CGlxGridViewContainer(MGlxMediaList *aMediaList,

        CGlxUiUtility* aUiUtility, MGlxGridEventObserver& aObserver,

        CAknToolbar* aToolbar) :

    iMediaList(aMediaList), iUiUtility(aUiUtility), iGlxGridViewObserver(

            aObserver), iToolbar(aToolbar)

    {

    TRACER("CGlxGridViewContainer::CGlxGridViewContainer");

    }

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

// Symbian 2nd phase constructor can leave.

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

//

void CGlxGridViewContainer::ConstructL()

	{

	TRACER("CGlxGridViewContainer::ConstructL()");

	//create the container window.

	CreateWindowL();

	// Making the default FSActivation as false

	iFullscreenViewActivated = EFalse;

	iNavigationalstate = CGlxNavigationalState::InstanceL();

	//check the navigational direction

	if (iUiUtility->ViewNavigationDirection ()== EGlxNavigationBackwards)

		{

		iBackwardActivation = ETrue;

		}

	// making the default mode of marking as false

	iMultipleMarkingActive = EFalse;

	iGridIconSize = iUiUtility->GetGridIconSize();

	iItemsPerPage = iUiUtility->VisibleItemsInPageGranularityL();

	// For DRM Utility

	iDRMUtility = CGlxDRMUtility::InstanceL();

    //Clear the last uri for which DRM Rights were consumed

    //since the GridView::Activate() and FullScreen::DeActivate() 

    //can be called in any order, this call is being made to be on safer side

    iDRMUtility->ClearLastConsumedItemUriL();

	// background Skin Context for the skin support

	TRect apRect = iEikonEnv->EikAppUi()->ApplicationRect();

	iBgContext = CAknsBasicBackgroundControlContext::NewL(

			KAknsIIDQsnBgScreen,apRect,ETrue);

	iQualityTnAttrib = TMPXAttribute (KGlxMediaIdThumbnail,

			GlxFullThumbnailAttributeId( ETrue,  iGridIconSize.iWidth,

					iGridIconSize.iHeight ) );

	iSpeedTnAttrib = TMPXAttribute (KGlxMediaIdThumbnail,

			GlxFullThumbnailAttributeId( EFalse,  iGridIconSize.iWidth,

					iGridIconSize.iHeight ) );

	CreateGridL();

   iIsDialogLaunched = EFalse;

   iIsMMCRemoved = EFalse;

   iMMCNotifier = CGlxMMCNotifier::NewL(*this);

	}

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

// From OfferKeyEventL

// Default implementation,

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

//

TKeyResponse CGlxGridViewContainer::OfferKeyEventL(const TKeyEvent &aKeyEvent, TEventCode aType)

	{

	TRACER("CGlxGridViewContainer::OfferKeyEventL()");

	TKeyResponse response = EKeyWasNotConsumed;

	CCoeControl::OfferKeyEventL(aKeyEvent,aType);

	if(aType == EEventKey)

		{

		switch(aKeyEvent.iCode)

			{

			case EKeyBackspace:

				{

				iGlxGridViewObserver.HandleGridEventsL(EGlxCmdDelete);

				response = EKeyWasConsumed;

				break;

				}

			default:

				response = EKeyWasNotConsumed;

				break;

			}

		}

	//send the unconsumed events from grid container to hg-grid to handle related key events

	if(response == EKeyWasNotConsumed)

		{

		response = iHgGrid->OfferKeyEventL(aKeyEvent,aType);

		}

	return response ;

	}

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

// Release

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

//

void CGlxGridViewContainer::Release(TInt /*aBufferStart*/, TInt/* aBufferEnd*/)

	{

	TRACER("CGlxGridViewContainer::Release()");

	// This has to do nothing on default

	}

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

// Request

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

//

void CGlxGridViewContainer::Request(TInt aRequestStart, TInt aRequestEnd,

		THgScrollDirection /*aDirection*/)

	{

	TRACER("CGlxGridViewContainer::Request()");

	RequestL(aRequestStart, aRequestEnd);

	}

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

// RequestL

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

//

void CGlxGridViewContainer::RequestL(TInt aRequestStart, TInt aRequestEnd)

	{

	TRACER("CGlxGridViewContainer::RequestL()");

	TInt visIndex = 0;

	TInt mediaCount = iMediaList->Count();

	aRequestStart = (aRequestStart<0 ? 0 : aRequestStart) ;

	aRequestEnd = (aRequestEnd>=mediaCount? (mediaCount-1) : aRequestEnd);

	GLX_LOG_INFO3("CGlxGridViewContainer::RequestL - aRequestStart(%d), "

			"aRequestEnd(%d), FirstIndexOnScreen(%d)", aRequestStart,

			aRequestEnd, iHgGrid->FirstIndexOnScreen());

	GLX_LOG_INFO1("CGlxGridViewContainer::Request - mediaCount(%d)",mediaCount);

	visIndex = iHgGrid->FirstIndexOnScreen();

	if(visIndex >= mediaCount )

		{

		visIndex = mediaCount-1;

		}

	if(visIndex<0 || mediaCount<=0)

		{

		visIndex = 0;

		}

	GLX_LOG_INFO1("CGlxGridViewContainer::Request - SetVisibleWindowIndex"

			" visIndex(%d)", visIndex);

	iMediaList->SetVisibleWindowIndexL(visIndex);

	if(mediaCount>0)

		{

		//Set the icons and refresh the screen only when the items are present

		for (TInt i=aRequestStart; i<= aRequestEnd; i++)

			{

			SetIconsL(i);

			TInt firstIndex = iHgGrid->FirstIndexOnScreen();

			firstIndex = (firstIndex<0 ? 0 : firstIndex);

			TInt lastOnScreen = firstIndex + iHgGrid->ItemsOnScreen() - 1;

			lastOnScreen = (lastOnScreen >mediaCount-1? mediaCount-1:lastOnScreen);

			if (i == lastOnScreen || (i == aRequestEnd && i < lastOnScreen))

				{

				if (HasRelevantThumbnail(i))

					{

					GLX_LOG_INFO1("CGlxGridViewContainer::Request - RefreshScreen"

							"  lastOnScreen / aRequestEnd i(%d)", i);

					iHgGrid->RefreshScreen(i);

					}

				}

			}

		}

	}

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

// HasRelevantThumbnail

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

//

TBool CGlxGridViewContainer::HasRelevantThumbnail(TInt aIndex)

	{

	TRACER("CGlxGridViewContainer::HasRelevantThumbnail()");

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

	const CGlxThumbnailAttribute* qualityTn = item.ThumbnailAttribute(

			iQualityTnAttrib );

	const CGlxThumbnailAttribute* speedTn = item.ThumbnailAttribute(

			iSpeedTnAttrib );

	if ( qualityTn || speedTn )

		{

		GLX_LOG_INFO("CGlxGridViewContainer::HasRelevantThumbnail() - TN avail");

		return ETrue;

		}

	return EFalse;

	}

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

// HandleSelectL

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

//

void CGlxGridViewContainer::HandleSelectL( TInt aIndex )

	{

    TRACER("CGlxGridViewContainer::HandleSelectL()");

	// Map the index of HG Grid and Medialist

	// Make sure that the Selection Index is inside medialist count

	if (aIndex <iMediaList->Count() && aIndex >=0)

		{

		iMediaList->SetFocusL(NGlxListDefs::EAbsolute, aIndex);

		}

	}

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

// HandleOpenL

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

//

void CGlxGridViewContainer::HandleOpenL( TInt aIndex )

	{

    TRACER("CGlxGridViewContainer::HandleOpenL()");

	// Make sure that the Selection Index is inside medialist count

		{

		if (!(iHgGrid->Flags() && CHgScroller::EHgScrollerSelectionMode))

			{

			// If not in marking mode, then open FS view

			iUiUtility->SetViewNavigationDirection(EGlxNavigationForwards);

			//Navigate to the next view

			//Item is selected, go to next view

			HandleEnterKeyEventL((TInt)EAknCmdOpen);

			}

		}

	}

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

// HandleEnterKeyEventL

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

//

void CGlxGridViewContainer::HandleEnterKeyEventL(TInt aCommand)

	{

	TRACER("CGlxGridViewContainer::HandleEnterKeyEventL()");

	HandleViewCommandL(aCommand);

	}

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

// HandleMarkingL

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

//

void CGlxGridViewContainer::HandleMarkingL( TInt aIndex, TBool aMarked )

	{

	TRACER("CGlxGridViewContainer::HandleMarkingL()");

	HandleMultipleMarkingL(aIndex,aMarked);

	}

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

// CreateHgGridWidgetL

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

//

void CGlxGridViewContainer::CreateHgGridWidgetL()

	{

	TRACER("CGlxGridViewContainer::CreateHgGridWidgetL()");

	TInt mediaCount = iMediaList->Count();

    GLX_DEBUG2("GlxGrid: CHgGrid::CreateHgGridWidgetL() "

            "mediaCount(%d)", mediaCount);

	if (!iHgGrid)

		{

        iHgGridImageSize = CHgGrid::PreferredImageSize();

        GLX_DEBUG3("GlxGrid: CHgGrid::PreferredImageSize() w(%d) h(%d)",

                iHgGridImageSize.iWidth, iHgGridImageSize.iHeight);

        iIconsFileName.Append(KDC_APP_BITMAP_DIR);

        iIconsFileName.Append(KGlxIconsFilename);

        // Create Hg grid object

        if (mediaCount)

            {

            CFbsBitmap* bitmap = NULL;

            CFbsBitmap* mask = NULL;

            AknsUtils::CreateIconLC(AknsUtils::SkinInstance(), KAknsIIDNone,

                    bitmap, mask, iIconsFileName,

                    EMbmGlxiconsQgn_prop_image_notcreated,

                    EMbmGlxiconsQgn_prop_image_notcreated_mask);

            __ASSERT_DEBUG(bitmap, Panic(EGlxPanicNullPointer));

            __ASSERT_DEBUG(mask, Panic(EGlxPanicNullPointer));

            AknIconUtils::SetSize(bitmap, CHgGrid::PreferredImageSize(),

                    EAspectRatioPreservedAndUnusedSpaceRemoved);

            AknIconUtils::SetSize(mask, CHgGrid::PreferredImageSize(),

                    EAspectRatioPreservedAndUnusedSpaceRemoved);

            iHgGrid = CHgGrid::NewL(GetHgGridRect(), mediaCount,

                    CGulIcon::NewL(bitmap, mask));

            CleanupStack::Pop(mask);

            CleanupStack::Pop(bitmap);

            for (TInt index=0; index<mediaCount; index++)

                {

                SetIconsL(index);

                }

            }

        else

            {

            iHgGrid = CHgGrid::NewL(GetHgGridRect(), mediaCount);

            }

		}

	// Setting to MopParent to update background skin

	iHgGrid->SetMopParent(this);

	// Setting Selction observer for getting callback on key event change

	iHgGrid->SetSelectionObserver(*this);

	// This Displays the scrollbar at the opening of the Grid view

	iHgGrid->SetScrollBarTypeL(CHgScroller::EHgScrollerTimeStrip );

	// Enable Buffer support

	iHgGrid->EnableScrollBufferL(*this, (KNoOfPages * iItemsPerPage),

			KBufferTresholdSize);

	// Enable Marking support

	iHgGrid->SetMarkingObserver(*this);

	iHgGrid->SetFocus(ETrue);

	/*

	 * note: don't push hggrid to the control stack

	 */

	}

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

// GetHgGridRect

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

//

TRect CGlxGridViewContainer::GetHgGridRect()

    {

    TRACER("CGlxGridViewContainer::GetHgGridRect()");    

    TRect clientrect = iEikonEnv->EikAppUi()->ClientRect();

    TRect apprect = iEikonEnv->EikAppUi()->ApplicationRect();

    if (apprect.Height() > apprect.Width())

        {

        //portrait:

        //height : apprect height - (status pane height + toolbar height + cba height)

        //width remains 360.

        clientrect.SetHeight(apprect.Height() - ((clientrect.iTl.iY)

                + (iToolbar->Size().iHeight)

                + (iEikonEnv->AppUiFactory()->Cba()->Rect().Height())));

        }

    else

        {

        //Landscape:

        //height : apprect - (status pane height + cba height)

        //width  : apprect width - toolbarwidth.

        clientrect.SetHeight(apprect.Height() - ((clientrect.iTl.iY)

                + (iEikonEnv->AppUiFactory()->Cba()->Rect().Height())));

        clientrect.SetWidth(apprect.Width() - iToolbar->Size().iWidth);

        }

    return clientrect;

    }

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

// CreateGridL

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

//

void CGlxGridViewContainer::CreateGridL()

	{

	TRACER("CGlxGridViewContainer::CreateGridL()");

#ifdef _DEBUG

    TTime startTime;

    GLX_LOG_INFO("CGlxGridViewContainer::CreateGridL(+)");  

    startTime.HomeTime();

#endif

	// Set the Grid thumbnail context and iterator

	SetGridThumbnailContextL();

	// Create HG Grid widget

	CreateHgGridWidgetL();

	// Create an observer and pass MediaList and HGGrid objects

	CreateGridMediaListObserverL();

	// Create Grid once again after returning from FS as No calls for handleItem added.

	CreateGridAfterFSDeactivatedL();

#ifdef _DEBUG

    TTime stopTime;

    stopTime.HomeTime();

    GLX_DEBUG2("CGlxGridViewContainer::CreateGridL(-) took <%d> us", 

                    (TInt)stopTime.MicroSecondsFrom(startTime).Int64());

#endif   	

	}

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

// SetGridThumbnailContextL

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

//

void CGlxGridViewContainer::SetGridThumbnailContextL()

	{

	TRACER("CGlxGridViewContainer::SetGridThumbnailContextL()");

	// show static items again

	iMediaList->SetStaticItemsEnabled(ETrue);

	iThumbnailContext = CGlxThumbnailContext::NewL( &iBlockyIterator ); // set the thumbnail context

	iThumbnailContext->SetDefaultSpec( iGridIconSize.iWidth,iGridIconSize.iHeight );

	iMediaList->AddContextL(iThumbnailContext, KGlxFetchContextPriorityNormal );

	}

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

// CreateGridMediaListObserverL

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

//

void CGlxGridViewContainer::CreateGridMediaListObserverL()

	{

	TRACER("CGlxGridViewContainer::CreateGridMediaListObserverL()");

	// Creating the Medialist observer for HG Grid