/*

 * 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

const TInt KNoOfPages(3);

const TInt KBufferTresholdSize(3); 						// in rows

// ======== 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");

	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();

	// 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();

	}

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

// 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 (aIndex <iMediaList->Count() && aIndex >=0)

		{

		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();

	if (!iHgGrid)

		{

        TSize tnSize = CHgGrid::PreferredImageSize();

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

                tnSize.iWidth, tnSize.iHeight);

		TFileName resFile(KDC_APP_BITMAP_DIR);

		resFile.Append(KGlxIconsFilename);

		CFbsBitmap* bitmap = AknIconUtils::CreateIconL(resFile,

				EMbmGlxiconsQgn_prop_image_notcreated);

        AknIconUtils::SetSize(bitmap, tnSize);

		// Create Hg grid object

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

		}

	// 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()");

	// 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();

	}

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

// 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

	iGlxGridMLObserver = CGlxGridViewMLObserver::NewL(*iMediaList, iHgGrid);

	}

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

// CreateGridAfterFSDeactivatedL

// On Returning from the FS View, There is no calls to the handle attribut available,

// So repeating the code to view Grid on FS return

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

//

void CGlxGridViewContainer::CreateGridAfterFSDeactivatedL()

	{

	TRACER("CGlxGridViewContainer::CreateGridAfterFSDeactivatedL()");

	if (iBackwardActivation)

		{

		TInt mlCount = iMediaList->Count();

		GLX_LOG_INFO1("CreateGridAfterFSDeactivatedL() mlCount=%d", mlCount);

		// Setting the Empty Text

		HBufC* emptyText =

		StringLoader::LoadLC(R_GRID_EMPTY_VIEW_TEXT);

		iHgGrid->SetEmptyTextL(*emptyText);

		CleanupStack::PopAndDestroy(emptyText);

		if (mlCount <= 0)

			{

			GLX_LOG_INFO("CreateGridAfterFSDeactivatedL() - SetEmptyTextL()");

			iHgGrid->DrawNow();

			}

		TInt focusIndex = iMediaList->FocusIndex();

		TSize setSize = CHgGrid::PreferredImageSize();

		TFileName resFile(KDC_APP_BITMAP_DIR);

		resFile.Append(KGlxIconsFilename);

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

			{

			SetIconsL(index);

			}