/*

* 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 class CCertManUIViewPersonal

*                Updates Options list depending of the number of

*                marked and unmarked certificates in the listbox.

*                Handles softkey and Option list commands.

*                Handles certificate deletion including confirmation and

*                read-only notes.

*                Shows certificate details view with appropriate

*                warning notes if certificate is corrupted/expired/not valid.

*

*/

// INCLUDE FILES

#include <aknmessagequerydialog.h>

#include <aknnotewrappers.h>            // for warning & information notes

#include <certmanui.rsg>

#include <ErrorUI.h>

#include "CertmanuiCertificateHelper.h"

#include "CertmanuiKeeper.h"

#include "CertmanuicontainerPersonal.h"

#include "CertmanuiSyncWrapper.h"

#include "Certmanui.hrh"

#include "CertmanuiCommon.h"

#include "CertManUILogger.h"

#include    <hlplch.h>                  // For HlpLauncher

#include    <featmgr.h>                 // For FeatureManager

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

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

// CCertManUIViewPersonal::CCertManUIViewPersonal(CCertManUIKeeper& aKeeper)

// : iKeeper(aKeeper), iCrMgr(iKeeper.CertManager())

// Constructor

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

//

CCertManUIViewPersonal::CCertManUIViewPersonal( CCertManUIKeeper& aKeeper )

: iKeeper( aKeeper )

    {

    CERTMANUILOGGER_WRITE_TIMESTAMP( "CCertManUIViewPersonal::CCertManUIViewPersonal" );

    }

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

// CCertManUIViewPersonal::~CCertManUIViewPersonal()

// Destructor

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

//

CCertManUIViewPersonal::~CCertManUIViewPersonal()

    {

    CERTMANUILOGGER_ENTERFN( "CCertManUIViewPersonal::~CCertManUIViewPersonal" );

    if ( iContainerPersonal )

        {

        AppUi()->RemoveFromViewStack( *this, iContainerPersonal );

        delete iContainerPersonal;

        }

    CERTMANUILOGGER_LEAVEFN( "CCertManUIViewPersonal::~CCertManUIViewPersonal" );

    }

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

// CCertManUIViewPersonal* CCertManUIViewPersonal::NewL(const TRect& /*aRect*/,

//                                CCertManUIKeeper& aKeeper)

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

//

CCertManUIViewPersonal* CCertManUIViewPersonal::NewL( const TRect& /*aRect*/,

                                CCertManUIKeeper& aKeeper )

    {

    CCertManUIViewPersonal* self = new ( ELeave ) CCertManUIViewPersonal( aKeeper );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CCertManUIViewPersonal* CCertManUIViewPersonal::NewLC(const TRect& /*aRect*/,

//                                 CCertManUIKeeper& aKeeper)

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

//

CCertManUIViewPersonal* CCertManUIViewPersonal::NewLC( const TRect& /*aRect*/,

                                 CCertManUIKeeper& aKeeper )

    {

    CCertManUIViewPersonal* self = new ( ELeave ) CCertManUIViewPersonal( aKeeper );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CCertManUIViewPersonal::ConstructL()

// EPOC two-phased constructor

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

//

void CCertManUIViewPersonal::ConstructL()

    {

    CERTMANUILOGGER_ENTERFN( "CCertManUIViewPersonal::ConstructL" );

    BaseConstructL( R_CERTMANUI_VIEW_MAIN_PERSONAL );

    CERTMANUILOGGER_LEAVEFN( "CCertManUIViewPersonal::ConstructL" );

    }

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

// CCertManUIViewPersonal::DynInitMenuPaneL(TInt aResourceId,CEikMenuPane* aMenuPane)

// Updates Options list with correct items depending on

// whether the listbox is empty or if it has any marked items

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

//

void CCertManUIViewPersonal::DynInitMenuPaneL(TInt aResourceId, CEikMenuPane* aMenuPane)

    {

    CERTMANUILOGGER_ENTERFN( "CCertManUIViewPersonal::DynInitMenuPaneL" );

    if (( iKeeper.iWrapper->IsActive() ) ||

        ( iContainerPersonal->iListBox->CurrentItemIndex() >= iKeeper.iUserLabelEntries.Count() ))

        {

        return;

        }

    const CListBoxView::CSelectionIndexArray* selections =

            iContainerPersonal->iListBox->SelectionIndexes();

    const TInt markedCount = selections->Count();

    const TInt currentItemIndex = iContainerPersonal->iListBox->CurrentItemIndex();

    switch ( aResourceId )

        {

        case R_CERTMANUI_VIEW_MENU_PERSONAL:

            {

            if( !FeatureManager::FeatureSupported( KFeatureIdHelp ) )

                {

                aMenuPane->DeleteMenuItem( EAknCmdHelp );

                }

            // the certificate list is empty, all except Exit are dimmed

            if ( currentItemIndex == -1 )

                {

                aMenuPane->SetItemDimmed( ECertManUICmdAppViewDtls, ETrue );

                aMenuPane->SetItemDimmed( ECertManUICmdAppDelete, ETrue );

                aMenuPane->SetItemDimmed( ECertManUICmdMoveToDevice, ETrue );

                aMenuPane->SetItemDimmed( ECertManUICmdMarkUnmark, ETrue );

                }

            else

                {

                if ( markedCount == 1 )

                    {

                    aMenuPane->SetItemDimmed( ECertManUICmdAppViewDtls, ETrue );

                    }

                if ( markedCount > 1 )

                    {

                    aMenuPane->SetItemDimmed( ECertManUICmdAppViewDtls, ETrue );

                    aMenuPane->SetItemDimmed( ECertManUICmdMoveToDevice, ETrue );

                    }

                if ( !iKeeper.iCertificateHelper->IsOneMarkedCertificateDeletable(

                        iContainerPersonal->iListBox, KCertTypePersonal ) )

                    {

                    aMenuPane->SetItemDimmed( ECertManUICmdAppDelete, ETrue );

                    aMenuPane->SetItemDimmed( ECertManUICmdMoveToDevice, ETrue );

                    }

                }

            break;

            }

        case R_CERTMANUI_MENUPANE_OPTIONS_MARKED:

            {

            if ( markedCount > 1 )

                {

                aMenuPane->SetItemDimmed( ECertManUICmdMoveToDevice, ETrue );

                }

            if ( !iKeeper.iCertificateHelper->IsOneMarkedCertificateDeletable(

                    iContainerPersonal->iListBox, KCertTypePersonal ) )

                {

                aMenuPane->SetItemDimmed( ECertManUICmdAppDelete, ETrue );

                }

            // not available for personal certificates

            aMenuPane->SetItemDimmed( ECertManUICmdMoveToPersonal, ETrue );

            }

            // FALLTHROUGH

        case R_CERTMANUI_MENU_PANE_MARK_UNMARK:

            {

            TInt index = 0;

            TKeyArrayFix key( 0, ECmpTInt );

            if ( selections->Find( currentItemIndex, key, index ) )

                {   // focus is on unmarked item

                aMenuPane->SetItemDimmed( ECertManUICmdUnmark, ETrue );

                }

            else

                {   // focus is on marked item

                aMenuPane->SetItemDimmed( ECertManUICmdMark, ETrue );

                }

            // if all items are marked, dim "mark all" option

            if ( markedCount == iContainerPersonal->iListBox->Model()->NumberOfItems() )

                {

                aMenuPane->SetItemDimmed( ECertManUICmdMarkAll, ETrue );

                }

            // if no items are marked, dim "unmark all" option

            if ( markedCount == 0 )

                {

                aMenuPane->SetItemDimmed( ECertManUICmdUnmarkAll, ETrue );

                }

            break;

            }

        default:

            break;

        }

  CERTMANUILOGGER_LEAVEFN( "CCertManUIViewPersonal::DynInitMenuPaneL" );

  }

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

// CCertManUIViewPersonal::Id() const

// Returns Personal view id

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

//

TUid CCertManUIViewPersonal::Id() const

    {

    return KCertManUIViewPersonalId;

    }

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

// CCertManUIViewPersonal::HandleCommandL(TInt aCommand)

// Handles Softkey and Options list commands

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

//

void CCertManUIViewPersonal::HandleCommandL(TInt aCommand)

    {

    CERTMANUILOGGER_ENTERFN( "CCertManUIViewPersonal::HandleCommandL" );

    if (( iKeeper.iWrapper->IsActive() ) ||

        ( iContainerPersonal->iListBox->CurrentItemIndex() >= iKeeper.iUserLabelEntries.Count() ))

        {

        return;

        }

    switch ( aCommand )

        {

        case EAknSoftkeyBack:

            {

            // Activate main view

            AppUi()->ActivateLocalViewL( KCertManUIViewMainId );

            break;

            }

        // put the view specific menu commands here

        case EAknCmdExit:

            {

            ((CAknViewAppUi*)iAvkonAppUi)->HandleCommandL( EAknCmdExit );

            break;

            }

        case ECertManUICmdAppViewDtls:

            {

            iKeeper.iCertificateHelper->MessageQueryViewDetailsL(

                iContainerPersonal->iListBox->CurrentItemIndex(), KCertTypePersonal, iEikonEnv );

            break;

            }

        case ECertManUICmdAppDelete:

            {

            if ( iKeeper.iCertificateHelper->ConfirmationQueryDeleteCertL( KCertTypePersonal,

                                                      iContainerPersonal->iListBox ))

                {

                // goes here if at least one certificate is deleted

                iCurrentPosition = iContainerPersonal->iListBox->CurrentItemIndex();

                iTopItem = iContainerPersonal->iListBox->TopItemIndex();

                iContainerPersonal->DrawListBoxL(iCurrentPosition, iTopItem );

                TRAPD( error, iKeeper.RefreshUserCertEntriesL() );

                if ( error != KErrNone )

                    {

                    if ( error == KErrCorrupt )

                        {

                        iKeeper.ShowErrorNoteL( error );

                        User::Exit( KErrNone );

                        }

                    else

                        {

                        // have to call straight away the Exit

                        // showing any error notes would corrupt the display

                        User::Exit( error );

                        }

                    }

                UpdateMenuBar();

                }

            break;

            }

       case ECertManUICmdMoveToDevice:

            {

            HBufC* prompt = StringLoader::LoadLC(

                        R_QTN_CM_CONF_MOVE_TO_DEVICE );

            TInt selection = iKeeper.iCertificateHelper->DisplayConfirmationLD(prompt);

            if ( selection )

                {                

                TInt focusPosition = 0;

                const CArrayFix<TInt>* array = iContainerPersonal->iListBox->SelectionIndexes();

                if ( array->Count() == 1 )

                    {

                    // item is marked

                    focusPosition = array->At( 0 );

                    }

                else

                    {

                    // There is no marked item. Select higlighted item 

                    focusPosition = iContainerPersonal->iListBox->CurrentItemIndex();

                    }

                CCTCertInfo* entry = iKeeper.iUserLabelEntries[ focusPosition ]->iUserEntry;

                // Move key first

                TCTKeyAttributeFilter keyFilter;

                keyFilter.iKeyId = entry->SubjectKeyId();

                keyFilter.iPolicyFilter =  TCTKeyAttributeFilter::EAllKeys;

                TRAPD( error, iKeeper.iCertificateHelper->MoveKeyL( keyFilter,

                                KCMFileKeyStoreTokenUid, KCMDeviceKeyStoreTokenUid ));

                if ( error == KErrNone )

                    {

                    // Move certificate

                    iKeeper.iCertificateHelper->MoveCertL( *entry, focusPosition, iContainerPersonal->iListBox,

                                    KCMFileCertStoreTokenUid, KCMDeviceCertStoreTokenUid );

                    TRAP( error, iKeeper.RefreshUserCertEntriesL() );

                    if ( error != KErrNone )

                        {

                        if ( error == KErrCorrupt )

                            {

                            iKeeper.ShowErrorNoteL( error );

                            User::Exit( KErrNone );

                            }

                        else

                            {

                            // have to call straight away the Exit

                            // showing any error notes would corrupt the display

                            User::Exit( error );

                            }

                        }

                    MDesCArray* itemList = iContainerPersonal->iListBox->Model()->ItemTextArray();

                    CDesCArray* itemArray = ( CDesCArray* )itemList;

                    if (( itemArray != NULL ) && ( itemArray->Count() == 0 ))

                        {

                        iCurrentPosition = 0;

                        iTopItem = 0;

                        iContainerPersonal->UpdateListBoxL( iCurrentPosition, iTopItem );

                        }

                     else

                        {

                        iCurrentPosition = iContainerPersonal->iListBox->CurrentItemIndex();

                        iTopItem = iContainerPersonal->iListBox->TopItemIndex();

                        }

                    iContainerPersonal->DrawListBoxL(iCurrentPosition, iTopItem );

                    UpdateMenuBar();

                    }

                }

            break;

            }

        case ECertManUICmdMark:

        case ECertManUICmdUnmark:

        case ECertManUICmdMarkAll:

        case ECertManUICmdUnmarkAll:

            {

            // Gets pointer of current listbox.

            CEikListBox* listbox = iContainerPersonal->iListBox;

            if ( listbox )

                {

                AknSelectionService::HandleMarkableListProcessCommandL(

                    aCommand, listbox );

                iKeeper.iCertificateHelper->HandleMarkableListCommandL( aCommand,

                                                iContainerPersonal->iListBox  );

                UpdateMenuBar();

                }

            break;

            }

        case EAknCmdHelp:

            {

            if( FeatureManager::FeatureSupported( KFeatureIdHelp ) )

                {

                HlpLauncher::LaunchHelpApplicationL( iEikonEnv->WsSession(), AppUi()->AppHelpContextL() );

                }

            break;

            }

        default:

            {

            AppUi()->HandleCommandL( aCommand );

            break;

            }

        }

    CERTMANUILOGGER_LEAVEFN( "CCertManUIViewPersonal::HandleCommandL" );

    }

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

// CCertManUIViewPersonal::HandleClientRectChange()

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

//

void CCertManUIViewPersonal::HandleClientRectChange()

    {

    if ( iContainerPersonal )

        {

        iContainerPersonal->SetRect( ClientRect() );

        }

    }

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

// CCertManUIViewPersonal::DoActivateL(const TVwsViewId& /*aPrevViewId*/,TUid /*aCustomMessageId*/, const TDesC8& /*aCustomMessage*/)

// Updates the view when opening it

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

//

void CCertManUIViewPersonal::DoActivateL(const TVwsViewId& aPrevViewId, TUid /*aCustomMessageId*/, const TDesC8& /*aCustomMessage*/)

    {

    CERTMANUILOGGER_ENTERFN( "CCertManUIViewPersonal::DoActivateL" );

    iKeeper.StartWaitDialogL( ECertmanUiWaitDialog );

    CleanupCloseWaitDialogPushL( iKeeper );

    TRAPD ( error, iKeeper.RefreshUserCertEntriesL() );

    if ( error != KErrNone )

        {

        if ( error == KErrCorrupt )

            {

            iKeeper.ShowErrorNoteL( error );

            User::Exit( KErrNone );

            }

        else

            {

            // have to call straight away the Exit

            // showing any error notes would corrupt the display

            User::Exit( error );

            }

        }

    // If this view is being activated from main view,

    // current position is 0. The declaration of KCertManUIViewMainId is

    // located in certmanuiviewid.h which is not public header --> constant

    // is being used.

    if( aPrevViewId.iViewUid == KCertManUIViewMainId )

        {

        iCurrentPosition = 0;

        }

    if ( iContainerPersonal )

        {

        ((CAknViewAppUi*)iAvkonAppUi)->RemoveFromViewStack( *this, iContainerPersonal );

        delete iContainerPersonal;

        iContainerPersonal = NULL;

        }

    iContainerPersonal = new ( ELeave ) CCertManUIContainerPersonal( *this, iKeeper );

    iContainerPersonal->SetMopParent(this);

    iContainerPersonal->ConstructL( ClientRect(), iCurrentPosition, iTopItem );

    iKeeper.ActivateTitleL( KViewTitleCertManUIPersonal );

    iContainerPersonal->DrawListBoxL( iCurrentPosition, iTopItem );

    ((CAknViewAppUi*)iAvkonAppUi)->AddToStackL( *this, iContainerPersonal );

    UpdateMenuBar();

    CleanupStack::PopAndDestroy();    // closes wait dialog

    CERTMANUILOGGER_LEAVEFN( "CCertManUIViewPersonal::DoActivateL" );

    }

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

// CCertManUIViewPersonal::DoDeactivate()

// Saves focus position when closing view

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

//

void CCertManUIViewPersonal::DoDeactivate()

    {

    CERTMANUILOGGER_ENTERFN( "CCertManUIViewPersonal::DoDeactivate" );

        {

        delete iContainerPersonal;

        iContainerPersonal = NULL;

        }

    CERTMANUILOGGER_LEAVEFN( "CCertManUIViewPersonal::DoDeactivate" );

    }

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

// CCertManUIViewPersonal::Container()

// Returns iContainerPersonal to be used in CertManUIContainerPersonal

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

//

CCoeControl* CCertManUIViewPersonal::Container()

    {

    return iContainerPersonal;

    }

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