/*

* Copyright (c) 2006 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: 

*		folder subscription dialog

*

*/

// INCLUDES

#include <impicmds.h>

#include <imum.rsg>

#include <MtmStore.h>

#include <msvuids.h>

#include <mtudcbas.h>

#include <mtmuibas.h>

#include <miuthdr.h>

#include <imapcmds.h>

#include <gulicon.h>

#include <GULUTIL.H>

#include <EIKCLB.H>

#include <EIKCLBD.H>

#include <EIKTXLBM.H>

#include <AknLists.h>

#include <AknIconArray.h>                   // CAknIconArray

#include <StringLoader.h>

#include <eikmenup.h>

#include <FeatMgr.h>                        // FeatureManager

#include <hlplch.h>                         // For HlpLauncher

#include <muiu.mbg>

#include <coemain.h>

#include <muiuoperationwait.h>

#include <aknquerydialog.h>

#include <AknInputBlock.h>					// CAknInputBlock

#include <aknsutils.h>

#include <aknsconstants.h>                  // Skinned icon ids

#include <mtudcbas.h>

#include "imapfoldersubscription.h"

#include "ImumPanic.h"

#include "imas.hrh"

#include "EmailUtils.H"

#include <data_caging_path_literals.hrh>

#include <csxhelp/mbxs.hlp.hrh>

// CONSTANTS

// Correct path is added to literal when it is used.

_LIT(KMuiuBitmapFile, "z:muiu.MBM");

const TInt KImumFolderArrayVisibleItems = 5;

const TInt KImumFolderIconArrayGranularity = 6;

const TInt KImumITextLength = 100;

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

// CImapSubscriptionDialog::NewL

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

CImapSubscriptionDialog* CImapSubscriptionDialog::NewL(

    TMsvId aServiceId,

    CMsvSession& aSession,

    TBool& aShouldExit )

	{

	CImapSubscriptionDialog* self=new(ELeave) CImapSubscriptionDialog(

        aServiceId,

        aSession,

        aShouldExit );

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

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

// CImapSubscriptionDialog::~CImapSubscriptionDialog

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

CImapSubscriptionDialog::~CImapSubscriptionDialog()

	{

	iSession.RemoveObserver(*this);

	if (iMtmStore)

		{

		iMtmStore->ReleaseMtmUi(KUidMsgTypeIMAP4);

		delete iMtmStore;

		}

	delete iContextEntry;

    delete iFolderListArray;

	}

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

// CImapSubscriptionDialog::CImapSubscriptionDialog

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

CImapSubscriptionDialog::CImapSubscriptionDialog(

    TMsvId aServiceId,

    CMsvSession& aSession,

    TBool& aShouldExit )

    :

    iServiceId(aServiceId),

	iSession(aSession),

    iShouldExit( aShouldExit )

	{

	}

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

// CImapSubscriptionDialog::ConstructL

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

void CImapSubscriptionDialog::ConstructL()

	{

    FeatureManager::InitializeLibL();

    CAknDialog::ConstructL( R_IMAS_SETTINGS_SUBSCRIBE_MENU );

    iSubscriptionsChanged = EFalse;

	iSession.AddObserverL(*this);

	iMtmStore=CMtmStore::NewL(iSession);

	iMtmUiData=&(iMtmStore->MtmUiDataL(KUidMsgTypeIMAP4));

	iMtmUi=&(iMtmStore->ClaimMtmUiL(KUidMsgTypeIMAP4));

	iMtmUi->BaseMtm().SwitchCurrentEntryL(iServiceId);

	TMsvSelectionOrdering selectionOrdering(KMsvGroupByType, EMsvSortByDetails, ETrue);

	iContextEntry=CMsvEntry::NewL(iSession, iServiceId, selectionOrdering);

    iFolderListArray = CImapFolderListArray::NewL( iSession, iServiceId );

    iOpenedFolderId = iServiceId;

	}

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

// CImapSubscriptionDialog::PreLayoutDynInitL

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

void CImapSubscriptionDialog::PreLayoutDynInitL()

	{

    TBool refreshed = EFalse;

    CAknQueryDialog* confDialog = CAknQueryDialog::NewL();

	if( confDialog->ExecuteLD( R_IMUM_CONNECT_FOR_UPDATE ) )

        {

        refreshed = ETrue;

        CreateOperationL( ERefreshFolderList );

        }

    if( refreshed )

        {

        iFolderListArray->RefreshFolderListArrayL();

        }

    CEikColumnListBox* listBox =

        static_cast< CEikColumnListBox* >( Control( EImasCIDFolderListBox ) );

    listBox->SetListBoxObserver( this );

    // Create scroll bar

    listBox->CreateScrollBarFrameL();

    listBox->ScrollBarFrame()->SetScrollBarVisibilityL(

        CEikScrollBarFrame::EOff, CEikScrollBarFrame::EAuto);

    CTextListBoxModel* model = listBox->Model();

    model->SetItemTextArray( iFolderListArray );

    listBox->Model()->SetOwnershipType( ELbmDoesNotOwnItemArray );

    HBufC* emptyText =

        StringLoader::LoadLC( R_IMAS_SETTINGS_DIALOG_SUBS_EMPTY_TEXT );

    listBox->View()->SetListEmptyTextL( emptyText->Des() );

    CArrayPtrFlat<CGulIcon>* icons

        = new(ELeave) CAknIconArray( KImumFolderIconArrayGranularity );

    CleanupStack::PushL( icons );

    // create icon array

    TFileName fileName;

    TParse tp;

    tp.Set( KMuiuBitmapFile, &KDC_APP_BITMAP_DIR, NULL );

    fileName.Copy( tp.FullName() );

    AppendIconsL( fileName, icons );

    reinterpret_cast<CAknSingleGraphicStyleListBox*>( listBox )->

        ItemDrawer()->ColumnData()->SetIconArray( icons );

    CleanupStack::Pop( ); // icons

    CleanupStack::PopAndDestroy();// emptyText

	}

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

// CImapSubscriptionDialog::PostLayoutDynInitL

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

void CImapSubscriptionDialog::PostLayoutDynInitL()

	{

    //nothing here

    }

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

// CImapSubscriptionDialog::SynchroniseFoldersL

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

void CImapSubscriptionDialog::SynchroniseFoldersL()

	{

	CreateOperationL(ERefreshFolderList);

	}

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

// CImapSubscriptionDialog::CreateOperationL

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

void CImapSubscriptionDialog::CreateOperationL(TInt aButtonId)

	{

	CMsvEntrySelection* mySelection=new (ELeave) CMsvEntrySelection;

	CleanupStack::PushL(mySelection);

	TBuf8<1> dummyParam;

    CMsvOperation* op = NULL;

    CMuiuOperationWait* wait = CMuiuOperationWait::NewLC();

	switch(aButtonId)

		{

	case EFolderSubscribe:

	case EFolderUnsubscribe:

        {

        //check for child / parent folders for question "want to subscribe/unsub whole tree branch?"

        //eat softkey commands. If user would leave while subscription process in progress, it will crash.

        //Only for subscribe operations. We need to be able to cancel folder list update operation

        CAknInputBlock::NewLC();

        HandleSubscriptionL( aButtonId, *mySelection );

        TInt cnt = mySelection->Count();

        if( cnt > 1 )

            {

            //if more than one folder, we need to do a batch of subscribe commands

            op = iMtmUi->InvokeAsyncFunctionL( KIMAP4MTMStartBatch,

			*mySelection, wait->iStatus, dummyParam);

            wait->Start();

            delete op;

            op = NULL;

            TInt i;

            for( i=0; i<cnt; i++ )

                {

                op = iMtmUi->InvokeAsyncFunctionL(

			        (aButtonId==EFolderSubscribe?KIMAP4MTMLocalSubscribe:KIMAP4MTMLocalUnsubscribe),

			        *mySelection, wait->iStatus, dummyParam);

                wait->Start();

                delete op;

                op = NULL;

                if( mySelection->Count() > 1 )

                    {

                    //don't delete the last one, otherwise next invokeasyncfunction crashes, there has to

                    //be something in the passed entry selection.

                    mySelection->Delete(0);//always delete the first item, so next will be the first

                    }

                }

            op = iMtmUi->InvokeAsyncFunctionL( KIMAP4MTMEndBatch,

			*mySelection, wait->iStatus, dummyParam);

            }//if

        else

            {

            //for only selected folder, no batch needed

            op = iMtmUi->InvokeAsyncFunctionL(

			    (aButtonId==EFolderSubscribe?KIMAP4MTMLocalSubscribe:KIMAP4MTMLocalUnsubscribe),

			    *mySelection, wait->iStatus, dummyParam);

            }

        }

		break;

	case ERefreshFolderList:

        mySelection->AppendL(iServiceId);

		op = iMtmUi->InvokeAsyncFunctionL(

			KImpiMTMRefreshFolderList, *mySelection, wait->iStatus ,dummyParam);

		break;

	default:

		break;

		};

    wait->Start();

    delete op;

    op = NULL;

    if( aButtonId == EFolderSubscribe || aButtonId == EFolderUnsubscribe )

        {

        CleanupStack::PopAndDestroy(); //CAknInputBlock

        }

	CleanupStack::PopAndDestroy(2);	// CSI: 47 # wait, mySelection

	}

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

// CImapSubscriptionDialog::OkToExitL

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

TBool CImapSubscriptionDialog::OkToExitL(TInt aButtonId)

	{

	TBool exit=EFalse;

    CEikColumnListBox* listBox = 

        static_cast<CEikColumnListBox*>( Control( EImasCIDFolderListBox ) );

    const TInt oldCount = listBox->Model()->NumberOfItems();

	switch(aButtonId)

		{

        case EAknSoftkeyOptions:

            return CAknDialog::OkToExitL( EAknSoftkeyOptions );

		case EFolderSubscribe:

		case EFolderUnsubscribe:

            iSubscriptionsChanged = ETrue;

            CreateOperationL( aButtonId );

            break;

        case EAknSoftkeyClose:

            //invokaa folder update jos ollaan online, tai promptaa connectia?

            if( iSubscriptionsChanged )

                {

                //HandleRefreshL();

                }

            exit = ETrue;

            break;

        case EFolderOpenFolder:

            // open folder which has subfolders...

	        iContextEntry->SetEntryL(CurrentFolderL());

            if ( ContextHasChildFolders() )

                {

                iOpenedFolderId = CurrentFolderL();

                iFolderListArray->ChangeFolderL( CurrentFolderL() );

                if ( listBox->Model()->NumberOfItems() )

                    {

                    listBox->SetTopItemIndex( 0 );

                    listBox->SetCurrentItemIndex( 0 );

                    }

                if ( oldCount > listBox->Model()->NumberOfItems() )

                    {

                    listBox->HandleItemRemovalL();

                    }

                else

                    {

                    listBox->HandleItemAdditionL();

                    }

                }

            break;

        case EAknSoftkeyBack:

            {

            if( iContextEntry->Entry().iType == KUidMsvServiceEntry )

                {

                //Only exit if current folder is service

                exit = ETrue;

                break;

                }

            TMsvId folderToBeSelected = iOpenedFolderId;

	        iContextEntry->SetEntryL( iOpenedFolderId );

            iOpenedFolderId = iContextEntry->Entry().Parent();

            iFolderListArray->ChangeFolderL( iOpenedFolderId );

	        iContextEntry->SetEntryL( iOpenedFolderId );

            if ( oldCount > listBox->Model()->NumberOfItems() )

                {

                listBox->HandleItemRemovalL();

                }

            else

                {

                listBox->HandleItemAdditionL();

                }

            TInt loop;

            for ( loop = iContextEntry->Count()-1; loop >= 0; loop-- )

                {

                if ( folderToBeSelected == (*iContextEntry)[loop].Id() )

                    {

                    break;

                    }

                }

            if ( loop < 0 )

                {

                loop = 0;

                }

            listBox->SetTopItemIndex( ( loop > KImumFolderArrayVisibleItems ? loop - KImumFolderArrayVisibleItems : 0 ) );

            listBox->SetCurrentItemIndex( loop );

            }

            break;

        case EEikCmdExit:

            exit = ETrue;

            iShouldExit = ETrue;//pass exit to settings dialog

            break;

	default:

		break;

		};

	listBox->DrawNow();

	return exit;

	}

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

// CImapSubscriptionDialog::ContextHasChildFolders

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

TBool CImapSubscriptionDialog::ContextHasChildFolders() const

	{

	TInt index=iContextEntry->Count()-1;

	while (index>=0 && (*iContextEntry)[index].iType!=KUidMsvFolderEntry)

		index--;

	if(index!=-1)

		return ETrue;

	return EFalse;

	}

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

// CImapSubscriptionDialog::HandleSessionEventL

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

void CImapSubscriptionDialog::HandleSessionEventL(TMsvSessionEvent aEvent, TAny* aArg1, TAny* /*aArg2*/, TAny* /*aArg3*/)

	{

	if(aEvent!=EMsvEntriesChanged)

		return;

    CMsvEntrySelection& sel=*static_cast<CMsvEntrySelection*>(aArg1);

	if(sel.Find(CurrentFolderL())!=KErrNotFound)

        {

		CEikColumnListBox* listBox = static_cast<CEikColumnListBox*>(Control(EImasCIDFolderListBox));

        listBox->DrawNow();

        }

	}

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

// CImapSubscriptionDialog::DisplayFinalProgressDialog

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

void CImapSubscriptionDialog::DisplayFinalProgressDialog(CMsvOperation& aCompletedOperation) const

	{

	__ASSERT_DEBUG(!aCompletedOperation.IsActive(), Panic(EIMAP4MtmUiOperationStillActive));

	iMtmUi->DisplayProgressSummary(aCompletedOperation.FinalProgress());

	}

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

// CImapSubscriptionDialog::AppendIconsL

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

void CImapSubscriptionDialog::AppendIconsL(

    TFileName& aFileName,

    CArrayPtrFlat<CGulIcon>* aIcons)

    {

    MAknsSkinInstance* skins = AknsUtils::SkinInstance();

    TAknsItemID id;

    CFbsBitmap* bitmap;

    CFbsBitmap* bitmapMask;

    TBool found = ETrue;

    for( TInt i=EMbmMuiuQgn_prop_folder_small; i<EMbmMuiuQgn_prop_folder_sub_unsubs_new+1; i++ )

        {

        CGulIcon* icon = NULL;

        found = ETrue;

        switch( i )

            {

            case EMbmMuiuQgn_prop_folder_small:

                id.Set( KAknsIIDQgnPropFolderSmall );

                break;

            case EMbmMuiuQgn_prop_folder_subs:

                id.Set( KAknsIIDQgnPropFolderSubs );

                break;

            case EMbmMuiuQgn_prop_folder_subs_new:

                id.Set( KAknsIIDQgnPropFolderSubsNew );

                break;

            case EMbmMuiuQgn_prop_folder_sub_small:

                id.Set( KAknsIIDQgnPropFolderSubSmall );

                break;

            case EMbmMuiuQgn_prop_folder_sub_subs:

                id.Set( KAknsIIDQgnPropFolderSubSubs );

                break;

            case EMbmMuiuQgn_prop_folder_sub_subs_new:

                id.Set( KAknsIIDQgnPropFolderSubSubsNew );

                break;

            case EMbmMuiuQgn_prop_folder_unsubs_new:

                id.Set( KAknsIIDQgnPropFolderUnsubsNew );

                break;

            case EMbmMuiuQgn_prop_folder_sub_unsubs_new:

                id.Set( KAknsIIDQgnPropFolderSubUnsubsNew );

                break;

            default:

                found = EFalse;

                break;

            }

        if( found )

            {

            AknsUtils::CreateIconL( skins, id, bitmap,

                bitmapMask, aFileName, i, i + 1 );

            icon = CGulIcon::NewL( bitmap, bitmapMask );

            // ownership of bitmap and mask transfered to icon

            CleanupStack::PushL( icon );

            aIcons->AppendL( icon );

            CleanupStack::Pop( icon ); // icon

            }

        }

    }

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

// CImapSubscriptionDialog::HandleListBoxEventL

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

void CImapSubscriptionDialog::HandleListBoxEventL(

    CEikListBox* /*aListBox*/,

    TListBoxEvent aEventType )

    {

    switch ( aEventType )