/*

* 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 <glxcollectionpluginall.hrh>

#include <glxcollectionpluginalbums.hrh>

#include <glxcollectionplugintype.hrh>

#include <glxnavigationalstate.h>

#include <glxfiltergeneraldefs.h>

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

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

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

const TInt KListDataWindowSize(8); // Visible page

const TInt KListNonVisibleDataWindowSize(32); // Visible page + 3 pages

const TInt KNoOfPages(4);

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

        }

    iGridIconSize = iUiUtility->GetGridIconSize();

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

    // No need to fetch the rear pages as we do not support looping	

    iThumbnailIterator.SetRangeOffsets(0, KListDataWindowSize);

    iTitleAttributeContext = CGlxDefaultAttributeContext::NewL();

    iTitleAttributeContext->SetRangeOffsets(0, KMaxTInt);

    iTitleAttributeContext->AddAttributeL(KMPXMediaGeneralTitle);

    iSubtitleAttributeContext = new (ELeave) CGlxAttributeContext(

            &iThumbnailIterator);

    iSubtitleAttributeContext->AddAttributeL(

            KGlxMediaCollectionPluginSpecificSubTitle);

    iMediaList->AddContextL(iTitleAttributeContext, KMaxTInt);

    iMediaList->AddContextL(iSubtitleAttributeContext, KGlxFetchContextPriorityNormal);

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

        {

        iNonVisibleThumbnailIterator.SetRangeOffsets(KListDataWindowSize,

                KListNonVisibleDataWindowSize);

        iNonVisibleSubtitleAttributeContext

                = new (ELeave) CGlxAttributeContext(

                        &iNonVisibleThumbnailIterator);

        iNonVisibleSubtitleAttributeContext->AddAttributeL(

                KGlxMediaCollectionPluginSpecificSubTitle);

        iMediaList->AddContextL(iNonVisibleSubtitleAttributeContext,

                KGlxFetchContextPriorityLow);

        CMPXCollectionPath* path = iMediaList->PathLC(

                NGlxListDefs::EPathParent);

        if (path->Id(0) == KGlxCollectionPluginAlbumsImplementationUid)

            {

            iOtherAttribsContext = new (ELeave) CGlxAttributeContext(

                &iThumbnailIterator);

            iOtherAttribsContext->AddAttributeL(KGlxMediaGeneralSystemItem);

            iOtherAttribsContext->AddAttributeL(

                    KGlxMediaGeneralSlideshowableContent);

            iMediaList->AddContextL(iOtherAttribsContext,

                    KGlxFetchContextPriorityNormal);

            iNonVisibleOtherAttribsContext = new (ELeave) CGlxAttributeContext(

                &iNonVisibleThumbnailIterator);

            iNonVisibleOtherAttribsContext->AddAttributeL(

                    KGlxMediaGeneralSystemItem);

            iNonVisibleOtherAttribsContext->AddAttributeL(

                    KGlxMediaGeneralSlideshowableContent);

            iMediaList->AddContextL(iNonVisibleOtherAttribsContext,

                    KGlxFetchContextPriorityLow);

            }

        CleanupStack::PopAndDestroy(path);

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

        iNonVisibleThumbnailContext = new (ELeave) CGlxAttributeContext(

                &iNonVisibleThumbnailIterator);

        iNonVisibleThumbnailContext->SetDefaultSpec(iGridIconSize.iWidth,

                iGridIconSize.iHeight);

        iNonVisibleThumbnailContext->AddAttributeL(tnAttr);

        iMediaList->AddContextL(iNonVisibleThumbnailContext,

                KGlxFetchContextPriorityLow);

        }

    iMediaList->AddMediaListObserverL(this);

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

    iBgContext = CAknsBasicBackgroundControlContext::NewL( 

            KAknsIIDQsnBgScreen,apRect,ETrue);

    iBackwardNavigation = (iUiUtility->ViewNavigationDirection()

            == EGlxNavigationBackwards);

    GLX_LOG_INFO1("CGlxListViewImp::DoMLViewActivateL() - "

            "iBackwardNavigation(%d)", iBackwardNavigation);

    iPreviewTNBinding = CGlxPreviewThumbnailBinding::NewL(*this);

    CreateListL();

    iProgressIndicator = CGlxProgressIndicator::NewL(*this);

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

       }

    RemoveContext();

	iMediaList->RemoveMediaListObserver( this );

	delete iPreviewTNBinding;

	iPreviewTNBinding = NULL;

	DestroyListViewWidget();

	if(iProgressIndicator)

	    {

        delete iProgressIndicator;

        iProgressIndicator = NULL;

	    }

	delete iMMCNotifier;

	iMMCNotifier = NULL;

	}

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

// RemoveContext

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

//

void CGlxListViewImp::RemoveContext()

    {

    TRACER("CGlxListViewImp::DoMLViewDeactivate");

    if (iTitleAttributeContext)

        {

        iMediaList->RemoveContext(iTitleAttributeContext);

        delete iTitleAttributeContext;

        iTitleAttributeContext = NULL;

        }

    if (iSubtitleAttributeContext)

        {

        iMediaList->RemoveContext(iSubtitleAttributeContext);

        delete iSubtitleAttributeContext;

        iSubtitleAttributeContext = NULL;

        }

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

        {

        if (iOtherAttribsContext)

            {

            iMediaList->RemoveContext(iOtherAttribsContext);

            delete iOtherAttribsContext;

            iOtherAttribsContext = NULL;

            }

        if (iThumbnailContext)

            {

            iMediaList->RemoveContext(iThumbnailContext);

            delete iThumbnailContext;

            iThumbnailContext = NULL;

            }

        if (iNonVisibleSubtitleAttributeContext)

            {

            iMediaList->RemoveContext(iNonVisibleSubtitleAttributeContext);

            delete iNonVisibleSubtitleAttributeContext;

            iNonVisibleSubtitleAttributeContext = NULL;

            }

        if (iNonVisibleOtherAttribsContext)

            {

            iMediaList->RemoveContext(iNonVisibleOtherAttribsContext);

            delete iNonVisibleOtherAttribsContext;

            iNonVisibleOtherAttribsContext = NULL;

            }

        if (iNonVisibleThumbnailContext)

            {

            iMediaList->RemoveContext(iNonVisibleThumbnailContext);

            delete iNonVisibleThumbnailContext;

            iNonVisibleThumbnailContext = NULL;

            }

        }

    }

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

// Destroys the Widget

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

//

void CGlxListViewImp::DestroyListViewWidget()

	{

	TRACER("CGlxListViewImp::DestroyListViewWidget");

    if (iList)

        {

   	    AppUi()->RemoveFromStack(iList);

        delete iList;

        iList = NULL;

        }

	delete iBgContext;

	iBgContext = NULL;

	if(iBackwardNavigation)

		{

		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)

        {