/*

* Copyright (c) 2003-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 class CCertManUIViewTrustedSite

*                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 note.

*                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 <X509CertNameParser.h>

#include <ErrorUI.h>

#include <x509cert.h>

#include <pkixcertchain.h>              //for validation

#include <certmanui.rsg>

#include "CertmanuiCertificateHelper.h"

#include "CertmanuiKeeper.h"

#include "CertmanuiviewTrustedSite.h"

#include "CertmanuicontainerTrustedSite.h"

#include "Certmanui.hrh"

#include "CertmanuiSyncWrapper.h"

#include "CertmanuiCommon.h"

#include "CertManUILogger.h"

#include    <hlplch.h>                  // For HlpLauncher

#include    <featmgr.h>                 // For FeatureManager

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

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

// CCertManUIViewTrustedSite::CCertManUIViewTrustedSite(CCertManUIKeeper& aKeeper)

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

// Constructor

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

//

CCertManUIViewTrustedSite::CCertManUIViewTrustedSite( CCertManUIKeeper& aKeeper )

    : iKeeper( aKeeper )

    {

    CERTMANUILOGGER_WRITE_TIMESTAMP(

        "CCertManUIViewTrustedSite::CCertManUIViewTrustedSite" );

    }

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

// CCertManUIViewTrustedSite::~CCertManUIViewTrustedSite()

// Destructor

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

//

CCertManUIViewTrustedSite::~CCertManUIViewTrustedSite()

    {

    CERTMANUILOGGER_ENTERFN( " CCertManUIViewTrustedSite::~CCertManUIViewTrustedSite" );

    if ( iContainerTrustedSite )

        {

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

        delete iContainerTrustedSite;

        }

     CERTMANUILOGGER_LEAVEFN( " CCertManUIViewTrustedSite::~CCertManUIViewTrustedSite" );

    }

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

// CCertManUIViewTrustedSite* CCertManUIViewTrustedSite::NewL(

//      const TRect& /*aRect*/, CCertManUIKeeper& aKeeper)

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

//

CCertManUIViewTrustedSite* CCertManUIViewTrustedSite::NewL(

    const TRect& /*aRect*/, CCertManUIKeeper& aKeeper )

    {

    CCertManUIViewTrustedSite* self =

        new ( ELeave ) CCertManUIViewTrustedSite( aKeeper );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CCertManUIViewTrustedSite* CCertManUIViewTrustedSite::NewLC(

//  const TRect& /*aRect*/, CCertManUIKeeper& aKeeper)

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

//

CCertManUIViewTrustedSite* CCertManUIViewTrustedSite::NewLC(

    const TRect& /*aRect*/, CCertManUIKeeper& aKeeper )

    {

    CCertManUIViewTrustedSite* self =

        new ( ELeave ) CCertManUIViewTrustedSite( aKeeper );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CCertManUIViewTrustedSite::ConstructL()

// EPOC two-phased constructor

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

//

void CCertManUIViewTrustedSite::ConstructL()

    {

    CERTMANUILOGGER_ENTERFN( " CCertManUIViewTrustedSite::ConstructL" );

    BaseConstructL( R_CERTMANUI_VIEW_MAIN_TRUSTED_SITE );

    CERTMANUILOGGER_LEAVEFN( " CCertManUIViewTrustedSite::ConstructL" );

    }

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

// CCertManUIViewTrustedSite::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 CCertManUIViewTrustedSite::DynInitMenuPaneL(

    TInt aResourceId, CEikMenuPane* aMenuPane )

    {

    CERTMANUILOGGER_ENTERFN( " CCertManUIViewTrustedSite::DynInitMenuPaneL" );

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

        ( iContainerTrustedSite->iListBox->CurrentItemIndex() >= iKeeper.iPeerLabelEntries.Count() ))

        {

        return;

        }

    const CListBoxView::CSelectionIndexArray* selections =

            iContainerTrustedSite->iListBox->SelectionIndexes();

    const TInt markedCount = selections->Count();

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

    switch ( aResourceId )

        {

        case R_CERTMANUI_VIEW_MENU_TRUSTED_SITES:

            {

             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( ECertManUICmdMarkUnmark, ETrue );

                }

            else

                {

                if ( markedCount > 0 )

                    {

                    aMenuPane->SetItemDimmed( ECertManUICmdAppViewDtls, ETrue );

                    }

                if ( !iKeeper.iCertificateHelper->IsOneMarkedCertificateDeletable(

                        iContainerTrustedSite->iListBox, KCertTypeTrustedSite ) )

                    {

                    aMenuPane->SetItemDimmed( ECertManUICmdAppDelete, ETrue );

                    }

                }

            break;

            }

        case R_CERTMANUI_MENUPANE_OPTIONS_MARKED:

            {

            if ( !iKeeper.iCertificateHelper->IsOneMarkedCertificateDeletable(

                    iContainerTrustedSite->iListBox, KCertTypeTrustedSite ) )

                {

                aMenuPane->SetItemDimmed( ECertManUICmdAppDelete, ETrue );

                }

            // not available for trusted site certificates

            aMenuPane->SetItemDimmed( ECertManUICmdMoveToDevice, ETrue );

            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 == iContainerTrustedSite->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( " CCertManUIViewTrustedSite::DynInitMenuPaneL" );

    }

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

// CCertManUIViewTrustedSite::Id() const

// Returns Authority view id

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

//

TUid CCertManUIViewTrustedSite::Id() const

    {

    return KCertManUIViewTrustedSiteId;

    }

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

// CCertManUIViewTrustedSite::HandleCommandL(TInt aCommand)

// Handles Softkey and Options list commands

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

//

void CCertManUIViewTrustedSite::HandleCommandL( TInt aCommand )

    {

    CERTMANUILOGGER_ENTERFN( " CCertManUIViewTrustedSite::HandleCommandL" );

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

        ( iContainerTrustedSite->iListBox->CurrentItemIndex() >= iKeeper.iPeerLabelEntries.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(

                iContainerTrustedSite->iListBox->CurrentItemIndex(), KCertTypeTrustedSite, iEikonEnv );

            break;

            }

        case ECertManUICmdAppDelete:

            {

            if ( iKeeper.iCertificateHelper->ConfirmationQueryDeleteCertL( KCertTypeTrustedSite,

                                                    iContainerTrustedSite->iListBox ) )

                {

                // goes here if at least one certificate is deleted

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

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

                iContainerTrustedSite->DrawListBoxL(iCurrentPosition, iTopItem );

                TRAPD( error, iKeeper.RefreshPeerCertEntriesL() );

                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 ECertManUICmdMark:

        case ECertManUICmdUnmark:

        case ECertManUICmdMarkAll:

        case ECertManUICmdUnmarkAll:

            {

            // Gets pointer of current listbox.

            CEikListBox* listbox = iContainerTrustedSite->iListBox;

            if ( listbox )

                {

                AknSelectionService::HandleMarkableListProcessCommandL(

                    aCommand, listbox );

                iKeeper.iCertificateHelper->HandleMarkableListCommandL(

                                      aCommand, iContainerTrustedSite->iListBox );

                UpdateMenuBar();

                }

            break;

            }

        case EAknCmdHelp:

            {

            if( FeatureManager::FeatureSupported( KFeatureIdHelp ) )

                {

                HlpLauncher::LaunchHelpApplicationL(

                   iEikonEnv->WsSession(), AppUi()->AppHelpContextL() );

                }

            break;

            }

        default:

            {

            AppUi()->HandleCommandL( aCommand );

            break;

            }

        }

    CERTMANUILOGGER_LEAVEFN( " CCertManUIViewTrustedSite::HandleCommandL" );

    }

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

// CCertManUIViewTrustedSite::HandleClientRectChange()

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

//

void CCertManUIViewTrustedSite::HandleClientRectChange()

    {

    if ( iContainerTrustedSite )

        {

        iContainerTrustedSite->SetRect( ClientRect() );

        }

    }

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

// CCertManUIViewTrustedSite::DoActivateL(const TVwsViewId& /*aPrevViewId*/,

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

// Updates the view when opening it

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

//

void CCertManUIViewTrustedSite::DoActivateL(

    const TVwsViewId& aPrevViewId,

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

    {

     CERTMANUILOGGER_ENTERFN( " CCertManUIViewTrustedSite::DoActivateL" );

     iKeeper.StartWaitDialogL( ECertmanUiWaitDialog );

     CleanupCloseWaitDialogPushL( iKeeper );

     TRAPD ( error, iKeeper.RefreshPeerCertEntriesL() );

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

        {

        ((CAknViewAppUi*)iAvkonAppUi)->RemoveFromViewStack(

            *this, iContainerTrustedSite );

        delete iContainerTrustedSite;

        iContainerTrustedSite = NULL;

        }

    iContainerTrustedSite = new (ELeave) CCertManUIContainerTrustedSite(

        *this, iKeeper );

    iContainerTrustedSite->SetMopParent( this );

    iContainerTrustedSite->ConstructL(

        ClientRect(), iCurrentPosition, iTopItem );

    if ( !iKeeper.iCertsDatOK )

        {

        iCurrentPosition = 0;

        iTopItem = 0;

        }

    iKeeper.ActivateTitleL( KViewTitleCertManUITrustedSite );

    iContainerTrustedSite->DrawListBoxL( iCurrentPosition, iTopItem );

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

    UpdateMenuBar();

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

    iKeeper.iStartup = EFalse;

    CERTMANUILOGGER_LEAVEFN( " CCertManUIViewTrustedSite::DoActivateL" );

    }

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

// CCertManUIViewTrustedSite::DoDeactivate()

// Saves focus position when closing view

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

//

void CCertManUIViewTrustedSite::DoDeactivate()

    {

    CERTMANUILOGGER_ENTERFN( " CCertManUIViewTrustedSite::DoDeactivate" );

    if ( iKeeper.iCertsDatOK )

        {

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

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

        // do not destroy iContainerTrustedSite here because

        // TrustSettings view needs it !

        }

    else

        {

        iCurrentPosition = 0;

        iTopItem = 0;

        }

    CERTMANUILOGGER_LEAVEFN( " CCertManUIViewTrustedSite::DoDeactivate" );

    }

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

// CCertManUIViewTrustedSite::Container()

// Returns iContainerTrustedSite to be used in CertManUiContainerTrustedSite

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

//

CCoeControl* CCertManUIViewTrustedSite::Container()

    {

    return iContainerTrustedSite;

    }

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

// CCertManUIViewTrustedSite::UpdateMenuBar()

// Updates the menu bar

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

//

void CCertManUIViewTrustedSite::UpdateMenuBar()

    {

    CEikButtonGroupContainer*  cba = Cba();

    if ( cba == NULL )

        {

        return;

        }

    if ( iKeeper.iPeerLabelEntries.Count() == 0 )

        {

        // No certificate. Don't show MSK

        UpdateCba( R_CERTMANUI_OPTIONS_OPEN_BACK );

        cba->MakeCommandVisible( ECertManUICmdAppViewDtls, EFalse );

        }

    else

        {

        if ( iContainerTrustedSite->iListBox->SelectionIndexes()->Count() > 0 )

            {

            MenuBar()->SetContextMenuTitleResourceId( R_CERTMANUI_MENUBAR_OPTIONS_MARKED );

            UpdateCba( R_CERTMANUI_OPTIONS_CONTEXT_BACK );

            }

        else

            {

            MenuBar()->SetMenuTitleResourceId( R_CERTMANUI_MENUBAR_VIEW_TRUSTED_SITES );

            UpdateCba( R_CERTMANUI_OPTIONS_OPEN_BACK );

            }

        cba->MakeCommandVisible( ECertManUICmdAppViewDtls, ETrue );

        }

    }

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

// CCertManUIViewTrustedSite::UpdateCba( TInt aCbaResourceId )

// Updates cba

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

//

void CCertManUIViewTrustedSite::UpdateCba( TInt aCbaResourceId )

    {

    CEikButtonGroupContainer*  cba = Cba();

    if ( cba )

        {

        cba->SetCommandSetL( aCbaResourceId );

        cba->DrawNow();

        }

    }

// End of File