/*

* Copyright (c) 2005-2007 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:  Phonebook 2 fetch dialog.

*

*/

// INCLUDE FILES

#include <CPbk2FetchDlg.h>

// Phonebook 2

#include "MPbk2FetchDlgPage.h"

#include "MPbk2FetchDlgPages.h"

#include "Pbk2FetchDlgPageFactory.h"

#include "CPbk2FetchResults.h"

#include <MPbk2AppUi.h>

#include <MPbk2ApplicationServices.h>

#include <MPbk2ContactViewSupplier.h>

#include <Pbk2UIControls.hrh>

#include <MPbk2ContactUiControl.h>

#include <MPbk2FetchDlgObserver.h>

#include <Pbk2UIControls.rsg>

#include <MPbk2ContactLinkIterator.h>

#include <CPbk2IconInfoContainer.h>

#include <Pbk2UID.h>

#include <CPbk2IconFactory.h>

#include <TPbk2IconId.h>

#include <MPbk2ExitCallback.h>

#include <TPbk2DestructionIndicator.h>

#include "CPbk2NamesListControl.h"

#include <CPbk2AppUiBase.h>

#include <MPbk2KeyEventHandler.h>

#include <MPbk2AppUi.h>

#include <MPbk2ApplicationServices.h>

#include <MPbk2ContactViewSupplier.h>

// Virtual Phonebook

#include <CVPbkContactLinkArray.h>

#include <CVPbkContactManager.h>

#include <MVPbkContactViewBase.h>

#include <MVPbkContactLink.h>

#include <MVPbkContactOperationBase.h>

#include <MVPbkStoreContact.h>

#include <MVPbkContactGroup.h>

#include <VPbkContactView.hrh>

// System includes

#include <barsread.h>

#include <avkon.rsg>

#include <aknnavide.h>

#include <aknappui.h>

#include <StringLoader.h>

#include <akntabgrp.h>

#include <AknsUtils.h>

#include <layoutmetadata.cdl.h>

// Debugging headers

#include <Pbk2Debug.h>

/// Unnamed namespace for local definitions

namespace {

const TInt KPbk2MSKControlId( CEikButtonGroupContainer::EMiddleSoftkeyPosition );

const TInt KFirstElement = 0;

const TInt KDefaultMinSelection = 1;

enum TPanicCode

    {

    EPanicInvalidResourceData = 1,

    EPanicPostCond_PreLayoutDynInitL,

    EPanicPreCond_ResetWhenDestroyed,

    };

void Panic(TInt aReason)

    {

    _LIT(KPanicText, "CPbk2FetchDlg");

    User::Panic(KPanicText, aReason);

    }

} /// namespace

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

// CPbk2FetchDlg::TParams::TParams

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

//

EXPORT_C CPbk2FetchDlg::TParams::TParams() :

        iFlags( EFetchSingle ),

        iResId( R_PBK2_SINGLE_ENTRY_FETCH_DLG ),

        iMarkedEntries( NULL ),

        iNamesListView( NULL ),

        iGroupsListView( NULL ),

        iCbaId( 0 ),

        iNaviPaneId( 0 ),

        iExitCallback( NULL ),

        iMinSelection( KDefaultMinSelection )

    {

    }

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

// CPbk2FetchDlg::TParams::TCleanupItem

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

//

EXPORT_C CPbk2FetchDlg::TParams::operator TCleanupItem()

    {

    return TCleanupItem(Cleanup,this);

    }

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

// CPbk2FetchDlg::TParams::Cleanup

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

//

void CPbk2FetchDlg::TParams::Cleanup(TAny* aPtr)

    {

    TParams* self = static_cast<TParams*>(aPtr);

    delete self->iMarkedEntries;

    self->iMarkedEntries = NULL;

    }

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

// CPbk2FetchDlg::TResData::ReadFromResource

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

//

inline void CPbk2FetchDlg::TResData::ReadFromResource

        ( TResourceReader& aReader )

    {

    iDialogId = aReader.ReadInt32();

    iCbaId = aReader.ReadInt32();

    iEmptyCbaId = aReader.ReadInt32();

    iNaviPaneId = aReader.ReadInt32();

    }

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

// CPbk2FetchDlg::CPbk2FetchDlg

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

//

inline CPbk2FetchDlg::CPbk2FetchDlg

        ( TParams aParams, MPbk2FetchDlgObserver& aObserver ) :

            iParams( aParams ),

            iObserver( aObserver ),

            iSelectPermitted( ETrue )

    {

    }

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

// CPbk2FetchDlg::~CPbk2FetchDlg

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

//

CPbk2FetchDlg::~CPbk2FetchDlg()

    {

    if (iDestroyedPtr)

        {

        *iDestroyedPtr = ETrue;

        }

    if ( iSelfPtr )

        {

        *iSelfPtr = NULL;

        }

    if ( iStoreConfiguration )

        {

        iStoreConfiguration->RemoveObserver( *this );

        }

    RemoveCommandFromMSK();

    delete iTabSkinDelay;

    delete iSelectionRestorer;

    delete iPages;

    delete iNaviDecorator;

    delete iDialogAccepter;

    delete iResults;

    delete iFocusedContactLink;

    }

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

// CPbk2FetchDlg::ConstructL

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

//

inline void CPbk2FetchDlg::ConstructL()

    {

    // Read resources

    TResourceReader reader;

    iCoeEnv->CreateResourceReaderLC( reader, iParams.iResId );

    iResData.ReadFromResource( reader );

    __ASSERT_ALWAYS( iResData.iDialogId != 0,

        Panic( EPanicInvalidResourceData ) );

    __ASSERT_ALWAYS( iResData.iCbaId != 0,

        Panic( EPanicInvalidResourceData ) );

    __ASSERT_ALWAYS( iResData.iEmptyCbaId != 0,

        Panic( EPanicInvalidResourceData ) );

    CleanupStack::PopAndDestroy(); // reader

    iExitRecord.ClearAll();

    CAknDialog::ConstructL( R_AVKON_MENUPANE_EMPTY );

    TCallBack accepter( TryAcceptSelectionL, this );

    iDialogAccepter =

        new (ELeave) CAsyncCallBack( accepter, CActive::EPriorityIdle );

    // Dialog tabs appear in status pane stack only after dialog is fully

    // constructed, so we need to delay tab skinning.

    // Even in PostLayoutDyninit tab group is wrong.

    // Must use higher priority than user input, so the user

    // has no chance to write into find box. Tab skinning resets

    // the find input.

    iTabSkinDelay = CIdle::NewL( CActive::EPriorityHigh );

    iTabSkinDelay->Start( TCallBack( DelaySkinning, this ));

    // Initialize whether MSK is enabled in current layout.

    // Currently AknLayoutUtils::MSKEnabled() returns ETrue

    // if the application supports MSK (constructed with EAknEnableMSK flag).

    // In addition Layout_Meta_Data::IsMSKEnabled() is expected to be called,

    // which checks from the layout data whether or not the MSK is supported 

    // in the current resolution/orientation. 

    // So if either one returns EFalse, then MSK is not shown.

    iMSKEnabled = (AknLayoutUtils::MSKEnabled() && Layout_Meta_Data::IsMSKEnabled());

    // Add the store observer.

    iStoreConfiguration = &Phonebook2::Pbk2AppUi()->ApplicationServices().StoreConfiguration();

    iStoreConfiguration->AddObserverL( *this );

    }

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

// CPbk2FetchDlg::NewL

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

//

EXPORT_C CPbk2FetchDlg* CPbk2FetchDlg::NewL

        ( TParams aParams, MPbk2FetchDlgObserver& aObserver )

    {

    CPbk2FetchDlg* dlg = new ( ELeave ) CPbk2FetchDlg( aParams, aObserver );

    CleanupStack::PushL( dlg );

    dlg->ConstructL();

    CleanupStack::Pop( dlg );

    return dlg;

    }

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

// CPbk2FetchDlg::AcceptDelayedFetchL

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

//

EXPORT_C void CPbk2FetchDlg::AcceptDelayedFetchL

        ( const TDesC8& aContactLink )

    {

    CVPbkContactLinkArray* linkArray = CVPbkContactLinkArray::NewLC

        ( aContactLink, Phonebook2::Pbk2AppUi()->ApplicationServices().

            ContactManager().ContactStoresL() );

    // Append the selected contact to results.

    if ( linkArray->Count() > 0 )

        {

        const MVPbkContactLink& link = linkArray->At( KFirstElement );

        iResults->AppendDelayedL( link );

        }

    CleanupStack::PopAndDestroy(); // linkArray

    }

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

// CPbk2FetchDlg::AcceptDelayedFetchL

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

//

EXPORT_C void CPbk2FetchDlg::DenyDelayedFetchL

        ( const TDesC8& aContactLink )

    {

    CVPbkContactLinkArray* linkArray = CVPbkContactLinkArray::NewLC

        ( aContactLink, Phonebook2::Pbk2AppUi()->ApplicationServices().

            ContactManager().ContactStoresL() );

    // Unmark the selected contact

    if ( linkArray->Count() > 0 )

        {

        const MVPbkContactLink& link = linkArray->At( KFirstElement );

        iResults->DenyAppendDelayedL( link );

        iPages->SelectContactL( link, EFalse );

        }

    CleanupStack::PopAndDestroy(); // linkArray

    }

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

// CPbk2FetchDlg::ExecuteLD

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

//

EXPORT_C TInt CPbk2FetchDlg::ExecuteLD()

    {

    return CEikDialog::ExecuteLD( iResData.iDialogId );

    }

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

// CPbk2FetchDlg::RequestExitL

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

//

void CPbk2FetchDlg::RequestExitL( TInt aCommandId )

    {

    iExitRecord.Set( EExitApproved );

    TryExitL( aCommandId );

    }

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

// CPbk2FetchDlg::ForceExit

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

//

void CPbk2FetchDlg::ForceExit()

    {

    iExitRecord.Set( EExitApproved );

    iExitRecord.Set( EExitOrdered );

    TRAPD( err, TryExitL( EAknSoftkeyBack ) );

    if ( err != KErrNone )

        {

        // If not nicely then use the force

        delete this;

        }

    }

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

// CPbk2FetchDlg::ResetWhenDestroyed

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

//

void CPbk2FetchDlg::ResetWhenDestroyed( MPbk2DialogEliminator** aSelfPtr )

    {

    __ASSERT_DEBUG(!aSelfPtr || *aSelfPtr == this,

        Panic(EPanicPreCond_ResetWhenDestroyed));

    iSelfPtr = aSelfPtr;

    }

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

// CPbk2FetchDlg::CreateCustomControlL

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

//

SEikControlInfo CPbk2FetchDlg::CreateCustomControlL( TInt aControlType )

    {

    SEikControlInfo ctrl;

    ctrl.iControl = NULL;

    ctrl.iTrailerTextId = 0;

    ctrl.iFlags = 0;

    ctrl.iControl = Pbk2FetchDlgPageFactory::CreateCustomControlL

        ( aControlType, this, *this );

    if ( aControlType == EPbk2CtNamesContactViewList )

        {

        iNamesListControl = static_cast<CPbk2NamesListControl*>(ctrl.iControl);

        }

    else if ( aControlType == EPbk2CtGroupsContactViewList )

        {

        iGroupListControl = static_cast<CPbk2NamesListControl*>(ctrl.iControl);

        }

    return ctrl;

    }

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

// CPbk2FetchDlg::PreLayoutDynInitL

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

//

void CPbk2FetchDlg::PreLayoutDynInitL()

    {

    CAknDialog::PreLayoutDynInitL();

    SetupStatusPaneL();

    iPages = Pbk2FetchDlgPageFactory::CreatePagesL

        ( *this, Phonebook2::Pbk2AppUi()->ApplicationServices().

            ContactManager() );

    iPages->ActiveFirstPageL();

    iResults = CPbk2FetchResults::NewL( Phonebook2::Pbk2AppUi()->

        ApplicationServices().ContactManager(),

        *this, *iPages, iObserver, *this );

    // Use the current page view because we know the first page is

    // names list view that contains all contacts that can be marked

    PageChangedL(iPages->CurrentPage().FetchDlgPageId());

    __ASSERT_DEBUG(iPages, Panic(EPanicPostCond_PreLayoutDynInitL));

    }

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

// CPbk2FetchDlg::OkToExitL

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

//

TBool CPbk2FetchDlg::OkToExitL( TInt aButtonId )

    {

    TBool okToExit = ETrue;

    TBool canceled = Canceled( aButtonId );

    TBool aborted = ( aButtonId == EEikBidCancel );

    if ( iExitRecord.IsSet( EExitApproved ) )

        {

        okToExit = ETrue;

        }

    else

        {

        if ( !canceled )

            {

            okToExit = CheckIsOkToExitL( aButtonId );

            }

        }

    // Only multiple fetch needs to wait buffered operations finished

    if ( !canceled && ( iParams.iFlags & EFetchMultiple ) )

        {

        iResults->WaitOperationsCompleteL();

        }

    // Notify observer

    if ( canceled )

        {

        iObserver.FetchCanceled();

        }

    else if ( okToExit && aborted )

        {

        // End key exit aborts the fetch

        iObserver.FetchAborted();

        ExitApplication( EAknCmdExit );

        }

    else if ( okToExit && !iExitRecord.IsSet( EExitApproved ) )

        {

        // Do not announce fetch completion if exit has already

        // been approved by the client

        TBool thisDestroyed = EFalse;

        iDestroyedPtr = &thisDestroyed;

        TPbk2DestructionIndicator indicator

            ( &thisDestroyed, iDestroyedPtr );

        iObserver.FetchCompletedL( &FetchDlgSelection() );

        if ( thisDestroyed )

            {

            // If this has been destroyed, don't return ok since

            // returning ETrue would make the base class to

            // commence more prosessing with already deleted objects

            okToExit = EFalse;

            }

        }

    // Client can prevent the exit here at the last step. This query

    // has to be done after the client has been told about fetch

    // completion/cancellation. If client has already approved

    // exit, do not query this.

    if ( okToExit && !iExitRecord.IsSet( EExitApproved ) &&

         !iObserver.FetchOkToExit() )

        {

        okToExit = EFalse;

        }

    if ( okToExit )

        {

        // Reset results

        iResults->ResetAndDestroy();

        }

    else

        {

        // Permit selection again

        iSelectPermitted = ETrue;

        }

    iExitRecord.Set( EExitOrdered );    // exit is now ordered and

                                        // when client later requests

                                        // exit, the ordered exit

                                        // becomes approved exit

    return okToExit;

    }

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

// CPbk2FetchDlg::PageChangedL

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

//

void CPbk2FetchDlg::PageChangedL( TInt aPageId )

    {

    iPages->HandlePageChangedL( aPageId );

    UpdateCbasL();

    }

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

// CPbk2FetchDlg::OfferKeyEventL

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

//

TKeyResponse CPbk2FetchDlg::OfferKeyEventL

        ( const TKeyEvent& aKeyEvent, TEventCode aType )

    {

    TKeyResponse result = EKeyWasNotConsumed;

    TBool selectContact = EFalse;

    if ( aKeyEvent.iCode == EKeyOK &&

            ( iParams.iFlags & EFetchSingle ) )

        {

        selectContact = ETrue;

        }

    else if ( aKeyEvent.iCode == EKeyPhoneSend )

        {

        if ( iParams.iFlags & EFetchCallItem ) 

            {

            // Send key is used to select the contact, but only when

            // operating in 'call item fetch' mode

            // As the call item fetch is a single fetch, fetch dialog

            // needs to be exited after item fetched.

            TryExitL( EAknSoftkeySelect );

            }

        else if ( iParams.iFlags & EFetchMultiple || 

                    ( ( iParams.iFlags & EFetchSingle ) && 

                        ( EStdKeyYes == aKeyEvent.iScanCode ) ) )

            {

            // Call key is inactive when operating in 'multifetch' mode

            // and 'single item fetch' mode. 

            // Call key should be active when operating in 'single item 

            // call fetch' mode

            return EKeyWasConsumed;

            }

        }

    else if ( aKeyEvent.iCode == EKeyEnter &&