/*

* 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 list view

*

*/

// INCLUDE FILES

#include "glxlistviewimp.h"

#include "glxpreviewthumbnailbinding.h"

#include <mpxcollectionutility.h>

#include <mpxcollectionpath.h>

#include <glxcollectiongeneraldefs.h>

#include <ganes/HgDoubleGraphicListFlat.h>

#include <ganes/HgItem.h>

#include <data_caging_path_literals.hrh>

#include <glxuistd.h>

#include <glxicons.mbg>

#include <gulicon.h>

#include <AknsBasicBackgroundControlContext.h>

#include <mglxmedialist.h>					//MGlxMediaList

#include <glxtracer.h>

#include <glxlog.h>							//Glx Logs

#include <glxlistviewplugin.rsg>

#include <aknViewAppUi.h>

#include <StringLoader.h>					//StringLoader		

#include <glxsetappstate.h>

#include <mglxcache.h>

#include <glxerrormanager.h>             // For CGlxErrormanager

#include <glxthumbnailcontext.h>

#include <glxthumbnailattributeinfo.h>

#include <glxcollectionpluginalbums.hrh>

#include <glxcollectionpluginmonths.hrh>

#include <glxcollectionplugintype.hrh>

#include <glxnavigationalstate.h>

#include <akntranseffect.h>  // For transition effects

#include <gfxtranseffect/gfxtranseffect.h>  // For transition effects

#include "glxgfxtranseffect.h"  // For transition effects

const TInt KListDataWindowSize(16);

const TInt KNoOfPages(4);

const TInt KGlxCollectionRootLevel = 1;

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

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

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

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

//

CGlxListViewImp::CGlxListViewImp(TInt aViewUid,

        const TListViewResourceIds& aResourceIds) :

    iViewUid(aViewUid), iResourceIds(aResourceIds), iIsRefreshNeeded(EFalse),

    iBackwardNavigation(EFalse)

    {

    }

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

// Two-phased constructor.

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

//

CGlxListViewImp* CGlxListViewImp::NewL(MGlxMediaListFactory* aMediaListFactory,

                                       TInt aViewUid, 

                                       const TListViewResourceIds& aResourceIds,                                        

                                       const TDesC& aTitle)

    {

    TRACER("CGlxListViewImp::NewL");

    CGlxListViewImp* self = CGlxListViewImp::NewLC(aMediaListFactory, aViewUid,

                                                                aResourceIds, aTitle);			

    CleanupStack::Pop(self);

    return self;

    }

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

// Two-phased constructor.

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

//

CGlxListViewImp* CGlxListViewImp::NewLC(MGlxMediaListFactory* aMediaListFactory,

                                        TInt aViewUid, 

                                        const TListViewResourceIds& aResourceIds,                                         

                                        const TDesC& aTitle)

    {	

    TRACER("CGlxListViewImp::NewLC");

    CGlxListViewImp* self = new (ELeave) CGlxListViewImp(aViewUid, aResourceIds);

    CleanupStack::PushL(self);

    self->ConstructL(aMediaListFactory, aTitle);

    return self;

    }

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

// Symbian 2nd phase constructor can leave.

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

// 

void CGlxListViewImp::ConstructL(MGlxMediaListFactory* aMediaListFactory, 

                                                            const TDesC& aTitle)

    {

    TRACER("CGlxListViewImp::ConsrtuctL");

    BaseConstructL(iResourceIds.iViewId);

    ViewBaseConstructL();

    MLViewBaseConstructL(aMediaListFactory, aTitle);

    // Create navigational state 

    iNavigationalState = CGlxNavigationalState::InstanceL();

    iNavigationalState->AddObserverL( *this );

    CAknToolbar* toolbar = Toolbar();

    if(toolbar)

        {

        toolbar->DisableToolbarL(ETrue);  

        }

    CGlxUiUtility* uiUtility = CGlxUiUtility::UtilityL();

    CleanupClosePushL(*uiUtility);

    iGridIconSize = uiUtility->GetGridIconSize();

    CleanupStack::PopAndDestroy(uiUtility);     

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

    SetToolbarObserver(this);

    }

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

// Destructor

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

//

CGlxListViewImp::~CGlxListViewImp()

    {    

    TRACER("CGlxListViewImp::~CGlxListViewImp");

    if ( iNavigationalState )

        {

        iNavigationalState->RemoveObserver(*this);

        iNavigationalState->Close();

        }

    delete iTitletext;  

    }

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

// ControlGroupId

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

//

TInt CGlxListViewImp::ControlGroupId() const

    {

    TRACER("CGlxListViewImp::ControlGroupId()");

    return reinterpret_cast<TInt>(this);

    }

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

// From CAknView

// Returns views id.

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

//

TUid CGlxListViewImp::Id() const

    {

    TRACER("CGlxListViewImp::Id()");

    return TUid::Uid(iViewUid);

    }

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

// From CAknView

// Handles a view activation.

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

//

void CGlxListViewImp::DoMLViewActivateL(const TVwsViewId& /* aPrevViewId */, 

        TUid /* aCustomMessageId */, const TDesC8& /* aCustomMessage */)

    {

    TRACER("CGlxListViewImp::DoMLViewActivateL");  

    TUint transitionID = (iUiUtility->ViewNavigationDirection()==

         EGlxNavigationForwards)?KActivateTransitionId:KDeActivateTransitionId;

    //Do the activate animation only for views other than mainlist view and

	//on backward navigation from any other views to main list view, since 

	//for the app start the animation effect is by default provided.

    if (iMediaList->IdSpaceId(0) != KGlxIdSpaceIdRoot || 

           transitionID == KDeActivateTransitionId) 

        {

    	GfxTransEffect::BeginFullScreen( transitionID, TRect(),

                                   AknTransEffect::EParameterType, 

                         AknTransEffect::GfxTransParam( KPhotosUid, 

                         AknTransEffect::TParameter::EEnableEffects) );   

    	GfxTransEffect::EndFullScreen();

    	}

    iNextViewActivationEnabled = ETrue;

    if(StatusPane())

        {

        StatusPane()->MakeVisible(ETrue);

        CEikStatusPane* statusPane = iEikonEnv->AppUiFactory()->StatusPane();

        CAknTitlePane* titlePane = ( CAknTitlePane* )statusPane->ControlL(

                TUid::Uid( EEikStatusPaneUidTitle ));     

        const TDesC* titletext = titlePane->Text();

        HBufC* temptitle = titletext->AllocLC();

        TPtr titleptr = temptitle->Des();

        titleptr.Trim();

        if(!temptitle->Length())

            {

            if( iTitletext )

                {

                // Set the required Title

                titlePane->SetTextL( *iTitletext );

                }

            }

        CleanupStack::PopAndDestroy(temptitle);        

        }

	GlxSetAppState::SetState(EGlxInListView);

    // Separate contexts so that some attributes are loaded before others

    iThumbnailIterator.SetRangeOffsets(KListDataWindowSize,

            KListDataWindowSize);

    iTitleAttributeContext = new (ELeave) CGlxAttributeContext(

            &iThumbnailIterator);

    iTitleAttributeContext->AddAttributeL(KMPXMediaGeneralTitle);

    iSubtitleAttributeContext = new (ELeave) CGlxAttributeContext(

            &iThumbnailIterator);

    iSubtitleAttributeContext->AddAttributeL(

            KGlxMediaCollectionPluginSpecificSubTitle);

    iMediaList->AddContextL(iTitleAttributeContext, KMaxTInt);

    iMediaList->AddContextL(iSubtitleAttributeContext, KMaxTInt);

    if (iMediaList->IdSpaceId(0) != KGlxIdSpaceIdRoot)

        {

        iThumbnailContext = new (ELeave) CGlxAttributeContext(

                &iThumbnailIterator);

        TMPXAttribute tnAttr(KGlxMediaIdThumbnail,

                GlxFullThumbnailAttributeId(ETrue, iGridIconSize.iWidth,

                        iGridIconSize.iHeight));

        iThumbnailContext->SetDefaultSpec(iGridIconSize.iWidth,

                iGridIconSize.iHeight);

        iThumbnailContext->AddAttributeL(tnAttr);

        iMediaList->AddContextL(iThumbnailContext,

                KGlxFetchContextPriorityNormal);

        }

    iMediaList->AddMediaListObserverL(this);

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

    iBgContext = CAknsBasicBackgroundControlContext::NewL( 

            KAknsIIDQsnBgScreen,apRect,ETrue);

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

        {

        iBackwardNavigation = ETrue;

        }

    iPreviewTNBinding = CGlxPreviewThumbnailBinding::NewL(*this);

    CreateListL();

    if (iMediaList->IdSpaceId(0) == KGlxIdSpaceIdRoot && iPreviewTNBinding

			&& iBackwardNavigation && iMediaList->FocusIndex() == 0)

		{

		GLX_LOG_INFO("CGlxListViewImp::DoMLViewActivateL() - HandleItemChangedL()");

		iPopulateListTNs = ETrue;

		CMPXCollectionPath* path = iMediaList->PathLC(

				NGlxListDefs::EPathFocusOrSelection);

		iPreviewTNBinding->HandleItemChangedL(*path, iPopulateListTNs,

				iIsRefreshNeeded, iBackwardNavigation);

		CleanupStack::PopAndDestroy(path);

		}

    iProgressIndicator = CGlxProgressIndicator::NewL(*this);

    iProgressIndicator->ShowProgressbarL();

    iMMCNotifier = CGlxMMCNotifier::NewL(*this);

    }

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

// From CAknView

// View deactivation function.

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

//

void CGlxListViewImp::DoMLViewDeactivate()

    {   

    TRACER("CGlxListViewImp::DoMLViewDeactivate");  

    if(StatusPane())

       {

       if(iTitletext)

          {

          delete iTitletext;

          iTitletext = NULL;

          }

       CEikStatusPane* statusPane = iEikonEnv->AppUiFactory()->StatusPane();

       TRAP_IGNORE(CAknTitlePane* titlePane = ( CAknTitlePane* )statusPane->ControlL(

               TUid::Uid( EEikStatusPaneUidTitle ));        

       iTitletext = titlePane->Text()->AllocL());

       }

    iMediaList->RemoveContext( iTitleAttributeContext );

   	delete iTitleAttributeContext;

   	iTitleAttributeContext = NULL;

    iMediaList->RemoveContext( iSubtitleAttributeContext );

   	delete iSubtitleAttributeContext;

   	iSubtitleAttributeContext = NULL;

    if (iMediaList->IdSpaceId(0) != KGlxIdSpaceIdRoot)

        {

        iMediaList->RemoveContext(iThumbnailContext);

        delete iThumbnailContext;

        iThumbnailContext = NULL;

        }   

	iMediaList->RemoveMediaListObserver( this );

	delete iPreviewTNBinding;

	iPreviewTNBinding = NULL;

	DestroyListViewWidget();

	if(iProgressIndicator)

	    {

        delete iProgressIndicator;

        iProgressIndicator = NULL;

	    }

	delete iMMCNotifier;

	iMMCNotifier = NULL;

	}

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

// Destroys the Widget

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

//

void CGlxListViewImp::DestroyListViewWidget()

	{

	TRACER("CGlxListViewImp::DestroyListViewWidget");

    if (iList)

        {

   	    AppUi()->RemoveFromStack(iList);

        delete iList;

        iList = NULL;

        }

	delete iBgContext;

	iBgContext = NULL;

		{

		iLastFocusedIndex = 0;

		}

	}

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

// From CGlxViewBase

// Command handling function.

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

//

TBool CGlxListViewImp::HandleViewCommandL(TInt aCommand)

    {

	TRACER("CGlxListViewImp::HandleViewCommandL");  

    if (aCommand == EAknCmdOpen)

    	{

    	//Navigational State to be used

        if( iNextViewActivationEnabled ) 

            {

            iNextViewActivationEnabled = EFalse;

            iUiUtility->SetViewNavigationDirection(EGlxNavigationForwards); 

            //Navigate to the next view

            CMPXCollectionPath* path =

            iMediaList->PathLC( NGlxListDefs::EPathFocusOrSelection );

            iCollectionUtility->Collection().OpenL(*path);

            CleanupStack::PopAndDestroy(path);  

            }

        return ETrue;

    	}

    else

    	{

    	return EFalse;

    	}

    }

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

//  Called by the framework when the application status pane

//  size is changed.  Passes the new client rectangle to the

//  AppView

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

//

void CGlxListViewImp::HandleStatusPaneSizeChange ( )

    {

    if ( iBgContext )

        {

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

        iBgContext->SetRect( apRect );

        }

    if(iList)

        {

        TRAP_IGNORE (iList->InitScreenL(ClientRect()); )

        }

    }

TTypeUid::Ptr CGlxListViewImp::MopSupplyObject(TTypeUid aId)

	{   

    if (iBgContext && aId.iUid == MAknsControlContext::ETypeId)

    	{

        return MAknsControlContext::SupplyMopObject(aId, iBgContext );

    	}

    return CAknView::MopSupplyObject(aId);

	}

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

        THgScrollDirection /*aDirection*/)

    {

    TRACER("CGlxListViewImp::Request");

    //Doing this to avoid codescanner warning.

    TRAP_IGNORE(RequestL(aRequestStart, aRequestEnd));    

    }

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

// RequestL

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

//

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

    {

    TRACER("CGlxListViewImp::RequestL()");

    TInt mediaCount = iMediaList->Count();

    GLX_LOG_INFO1("CGlxListViewImp::RequestL - mediaCount(%d)", mediaCount);

    if(mediaCount<=0)

        {

        return;

        }

    TInt visIndex = iList->FirstIndexOnScreen();

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

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

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

       "aRequestEnd(%d), visIndex(%d)", aRequestStart, aRequestEnd, visIndex);

    if (visIndex >= mediaCount )

        {

        visIndex = mediaCount-1;

        }

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

        {

        visIndex = 0;

        }

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

        {

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

        iList->ItemL(i).SetTitleL(item.Title());

        iList->ItemL(i).SetTextL(item.SubTitle());

        UpdatePreviewL(i);

        }

    iList->RefreshScreen(visIndex);

    if(iMediaList->IdSpaceId(0) == KGlxIdSpaceIdRoot)

        {

        if ( visIndex != iLastFocusedIndex && !iPopulateListTNs)

            {

            GLX_LOG_INFO1("CGlxListViewImp::RequestL - SetFocusL()"

                    " iPopulateListTNs(%d)", iPopulateListTNs);      

            GLX_LOG_INFO1("CGlxListViewImp::RequestL - SetFocusL()"

                    " visIndex(%d)", visIndex);

            iPopulateListTNs = ETrue;

            iStartIndex = KErrNotFound;

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

            }

        }

    else

        {

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

        }

    }

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

    {

    TRACER("CGlxListViewImp::Release");

    }

void CGlxListViewImp::HandleSelectL( TInt aIndex )

    {

    TRACER("CGlxListViewImp::HandleSelectL");

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

    	{

    	iPopulateListTNs = EFalse;

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

    	}

    }

void CGlxListViewImp::HandleOpenL( TInt aIndex )

    {

    TRACER("CGlxListViewImp::HandleOpenL");

#ifndef __WINSCW__ 

    GLX_LOG_INFO1("CGlxListViewImp RProperty::Get leftVariable %d",(iUiUtility->GetItemsLeftCount()));

    if (iUiUtility->GetItemsLeftCount())

        {

        if(!iProgressIndicator)

            {

            iProgressIndicator = CGlxProgressIndicator::NewL(*this);

            }

        iProgressIndicator->ShowProgressbarL();

        if(iSchedulerWait)

            {