/*

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

*

*/

#include <aknnavi.h>

#include <aknnavide.h>

#include <eikbtgpc.h>

#include <AknIconUtils.h>

#include <aknselectionlist.h>

#include <gulicon.h>

#include <mnrefprovider.rsg>

#include <MnRefProvider.mbg>

#include "mnrp.hrh"

#include <EPos_CPosLandmark.h>

#include <EPos_CPosLandmarkDatabase.h>

#include "mnrpappview.h"

#include "mnrpnaviview.h"

#include "mnrpmapview.h"

#include "mnrpmapviewservice.h"

#include "mnrpnavigationservice.h"

#include "mnrpdocument.h"

#include "mnrpengine.h"

#include "mnrpappui.h"

#include "mnrputils.h"

#include "debug.h"

const TInt KDefaultLmIconIndex = 0;

_LIT( KMbmFile, "\\resource\\apps\\MnRefProvider.mbm");

// ============================ LOCAL FUNCTIONS ===============================

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

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

//

void CleanupIconArray( TAny* aArray )

    {

    LOG("MnRefProvider::CleanupIconArray in");

    ( ( CArrayPtrSeg<CGulIcon>* ) aArray)->ResetAndDestroy();

    delete aArray;

    LOG("MnRefProvider::CleanupIconArray out");

    }

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

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

//

void AddIconL(

    CArrayPtr<CGulIcon>& aIconArray,

    const TDesC& aFileName,

    TInt aIconIndex,

    TInt aMaskIndex )

    {

    LOG("MnRefProvider::AddIconL in");

    CFbsBitmap* icon = NULL;

    CFbsBitmap* mask = NULL;

    AknIconUtils::CreateIconLC( icon, mask, aFileName, aIconIndex, aMaskIndex );

    CGulIcon* gul = CGulIcon::NewL( icon, mask );

    gul->SetBitmapsOwnedExternally( EFalse );

    CleanupStack::PushL( gul );

    aIconArray.AppendL( gul );

    CleanupStack::Pop( 3 ); // gul, icon & mask

    LOG("MnRefProvider::AddIconL out");

    }

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

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

//

CArrayPtrSeg<CGulIcon>* CreateIconListLC( TInt aGranularity )

    {

    CArrayPtrSeg<CGulIcon>* iconList =

        new (ELeave) CArrayPtrSeg<CGulIcon>( aGranularity );

    CleanupStack::PushL( TCleanupItem( CleanupIconArray, iconList ) );

    AddIconL(

        *iconList,

        KMbmFile,

        EMbmMnrefproviderDefault_lm,

        EMbmMnrefproviderDefault_lm_mask);

    return iconList;

    }

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

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

//

void AddLandmarkL(

    const CPosLandmark& aLandmark,

    CDesCArray& aTextArray,

    CArrayPtr<CGulIcon>& aIconArray )

    {

    TPtrC name;

    aLandmark.GetLandmarkName( name );

    HBufC* printableName = MnrpUtils::PrintableStringLC( name );

    TPtrC iconFile;

    TInt iconIndex, maskIndex, iconArrayIndex;

    if ( aLandmark.GetIcon( iconFile, iconIndex, maskIndex ) == KErrNone )

        {

        AddIconL( aIconArray, iconFile, iconIndex, maskIndex );

        iconArrayIndex = aIconArray.Count() - 1;

        }

    else

        {

        iconArrayIndex = KDefaultLmIconIndex;

        }

    _LIT(KListItemFormat, "%d\t%S\t\t");

    const TInt KListItemMinSize = 20;

    HBufC* item = HBufC::NewLC( printableName->Size() + KListItemMinSize );

    item->Des().Format( KListItemFormat, iconArrayIndex, printableName );

    aTextArray.AppendL( *item );

    CleanupStack::PopAndDestroy( item );

    CleanupStack::PopAndDestroy( printableName );

    }

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

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

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

//

CMnrpAppUi::CMnrpAppUi( CMnrpEngine& aEngine )

  : iEngine( aEngine )

    {

    }

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

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

//

void CMnrpAppUi::ConstructL()

    {

    BaseConstructL( EAknEnableSkin );

    // This is empty view, it will be shown by UI framework,

    // when application starts

    iAppView = CMnrpAppView::NewL();

    AddViewL( iAppView );

    if ( !iEikonEnv->StartedAsServerApp() )

        {

        // switch to map view if started normally

        iMapView = CMnrpMapView::NewL( EFalse, iEngine );

        AddViewL( iMapView );

        ActivateLocalViewL( iMapView->Id() );

        }

    }

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

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

//

CMnrpAppUi::~CMnrpAppUi()

    {

    delete iNaviPaneLabel;

    }

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

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

//

void CMnrpAppUi::HandleCommandL( TInt aCommand )

    {

    switch(aCommand)

        {

        case EAknSoftkeyBack:

        	{

    	    CEikAppServer* server = iEikonEnv->AppServer();

		    if ( server )

		    	{

		        server->NotifyServerExit( EEikCmdExit );

		    	}

		    Exit();	

        	break;

        	}

        case EEikCmdExit:

        case EAknSoftkeyExit:

            {

    	    CEikAppServer* server = iEikonEnv->AppServer();

		    if ( server )

		    	{

		        server->NotifyServerExit( EAknCmdExit ); // this will close client also

		    	}

		    Exit();	

        	break;

            }

        default:

            break;

        }

    }

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

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

//

TBool CMnrpAppUi::IsChainedMode()

    {

    return ( iParentWg != 0 );

    }

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

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

//

TBool CMnrpAppUi::IsAnyUserViewActive()

    {

    TVwsViewId viewId;

    if ( ( GetActiveViewId( viewId ) == KErrNotFound ) ||

         ( viewId.iViewUid.iUid != EMnrpMapViewId && 

           viewId.iViewUid.iUid != EMnrpNavigationViewId ) )

        {

        return EFalse;

        }

    else

        {

        return ETrue;

        }

    }

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

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

//

void CMnrpAppUi::SetNaviPaneTitleL( const TDesC& aPaneTitle )

    {

    if ( !iNaviPane )

        {

        iNaviPane = static_cast<CAknNavigationControlContainer*>(

                StatusPane()->ControlL( TUid::Uid( EEikStatusPaneUidNavi ) ) );

        }

    if ( iNaviPaneLabel )

        {

        CAknNavigationDecorator* naviLabel = iNaviPane->CreateNavigationLabelL( aPaneTitle );

        CleanupStack::PushL( naviLabel );

        iNaviPane->ReplaceL( *iNaviPaneLabel, *naviLabel );

        delete iNaviPaneLabel;

        iNaviPaneLabel = naviLabel;

        CleanupStack::Pop( naviLabel );

        }

    else

        {

        iNaviPaneLabel = iNaviPane->CreateNavigationLabelL( aPaneTitle );

        iNaviPane->PushL( *iNaviPaneLabel );

        }

    }    

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

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

//

void CMnrpAppUi::SetRightSoftkeyCommandL( TInt aCommand, const TDesC& aButtonTitle )

    {

    if ( Cba() )

        {

        Cba()->SetCommandL( 1, aCommand, aButtonTitle );

        }

    }

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

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

//

TBool CMnrpAppUi::ProcessCommandParametersL( CApaCommandLine &aCommandLine )

    {

    iParentWg = aCommandLine.ParentWindowGroupID();

    LOG1("parent window group id %d", iParentWg );

    return CAknAppUi::ProcessCommandParametersL( aCommandLine );

    }

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

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

//

void CMnrpAppUi::HandleResourceChangeL( TInt aType )

    {

    CAknAppUi::HandleResourceChangeL( aType );

    TRect rect( ClientRect() );

    if ( Cba() )

        {

		Cba()->SetBoundingRect( TRect() );

		Cba()->ReduceRect( rect );

        }

    }

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

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

//

void CMnrpAppUi::ShowMapL( CMnrpMapViewService& aService )

    {

    if ( !iMapView )

        {

        iMapView = CMnrpMapView::NewL( IsChainedMode(), iEngine );

        AddViewL( iMapView );

        }

    iMapView->SetMapModeL( aService );

    ActivateLocalViewL( iMapView->Id() );

    }

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

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

//

void CMnrpAppUi::ShowNavigationL( const CPosLandmark& aDestination )

    {

    if ( !iNaviView )

        {

        iNaviView = CMnrpNaviView::NewL( IsChainedMode(), iEngine );

        AddViewL( iNaviView );

        }

    iNaviView->SetDestinationL( aDestination );

    ActivateLocalViewL( iNaviView->Id() );

    }

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

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

//

void CMnrpAppUi::StartSelectionL( 

    CMnrpMapViewService& aService,  

    MMapSelectionCallback& aCallback )

    {

	SetNaviPaneTitleL( aService.SelectionRequestText() );

    if ( aService.Options() & CMnMapView::EOptionRestrictSelection )

        {

        // select from dialog 

        SelectFromDialogL( aService, aCallback );

        }

    else

        {

        // select from map

        if ( !iMapView )

            {

            iMapView = CMnrpMapView::NewL( IsChainedMode(), iEngine );

            AddViewL( iMapView );

            }

        iMapView->SetSelectionModeL( aService, aCallback );

        ActivateLocalViewL( iMapView->Id() );

        }

    }

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

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

//

void CMnrpAppUi::StopSelection()

    {

    __ASSERT_DEBUG( iMapView, Panic( KErrGeneral ) );

    iMapView->StopSelection();

    // Selection is done - close selection view

    TRAP_IGNORE( ActivateLocalViewL( iAppView->Id() ) );

    }

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

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

//

void CMnrpAppUi::SelectFromDialogL(

    CMnrpMapViewService& aService,

    MMapSelectionCallback& aCallback )

    {

    LOG("MnRefProvider::SelectFromDialogL in");

    const TInt KGranularity = 8;

    CDesCArraySeg *textArray = new (ELeave) CDesCArraySeg( KGranularity );

    CleanupStack::PushL( textArray );

    CArrayPtrSeg<CGulIcon>* iconArray = CreateIconListLC( KGranularity );

    TInt linkedLmsOffset = 0;

    CMnrpDocument* doc = ( CMnrpDocument* ) Document();

    CMnrpEngine& engine = doc->Engine();

    // add non-linked landmarks

    LOG("MnRefProvider::DoSelectionDialogL adding non-linked landmarks");

    for ( TInt i = 0; i < aService.LandmarksToShow().Count(); i++)

        {

        const CPosLandmark* lm = aService.LandmarksToShow()[i];

        AddLandmarkL( *lm, *textArray, *iconArray );

        }

    // add linked landmarks

    LOG("MnRefProvider::DoSelectionDialogL adding linked landmarks");

    // create dictionary of linked landmarks

    // in order to ease searching for return values

    // when completing request

    RArray<TInt> dbIndices;

    RArray<TPosLmItemId> lmIds;

    CleanupClosePushL( dbIndices );

    CleanupClosePushL( lmIds );

    linkedLmsOffset = textArray->Count();

    for ( TInt db = 0; db < aService.LandmarksToShowDatabases().Count(); db++ )

        {

        const HBufC* uri = aService.LandmarksToShowDatabases()[db];

        CPosLandmarkDatabase* lmdb = CPosLandmarkDatabase::OpenL( *uri );

        CleanupStack::PushL( lmdb );

        if ( lmdb->IsInitializingNeeded() )

            {

            ExecuteAndDeleteLD( lmdb->InitializeL() );

            }

        for ( TInt i = 0; i < aService.LinkedLandmarksToShow(db).Count(); i++)

            {

            TPosLmItemId id = aService.LinkedLandmarksToShow(db)[i];

            CPosLandmark* lm = lmdb->ReadLandmarkLC( id );

            AddLandmarkL( *lm, *textArray, *iconArray );

            dbIndices.AppendL( db );

            lmIds.AppendL( id );

            CleanupStack::PopAndDestroy( lm );

            }

        CleanupStack::PopAndDestroy( lmdb );

        }

    TInt selected = 0;

    CAknSelectionListDialog *dialog =

        CAknSelectionListDialog::NewL( selected, textArray, R_MNREFPROVIDER_MENUBAR );

    dialog->PrepareLC( R_MNREFPROVIDER_SELECTION_DIALOG );

    dialog->SetIconArrayL( iconArray );

    CleanupStack::Pop(); // iconArray cleanup

    LOG1("MnRefProvider::SelectFromDialogL launching dialog with %d items", textArray->Count() );

    TInt result = dialog->RunLD();

    if ( result )

        {

        LOG("MnRefProvider::SelectFromDialogL approved");

        if ( selected < linkedLmsOffset )

            {

            aCallback.HandleSelectionL( selected );

            }

        else

            {

            TInt linkedLmIndex = selected - linkedLmsOffset;

            if ( linkedLmIndex < dbIndices.Count() && 

                 linkedLmIndex < lmIds.Count() )

                {

                aCallback.HandleSelectionL( lmIds[linkedLmIndex], dbIndices[linkedLmIndex] );

                }

            else

                {

                // never happens

                LOG("MnRefProvider::SelectFromDialogL selection out of range, out");

                aCallback.HandleSelectionErrorL( KErrGeneral );

                }

            }

        }

    else

        {

        LOG("MnRefProvider::SelectFromDialogL cancelled, out");

        aCallback.HandleSelectionErrorL( KErrCancel );

        }

    CleanupStack::PopAndDestroy( &lmIds );

    CleanupStack::PopAndDestroy( &dbIndices );

    CleanupStack::PopAndDestroy( textArray );

    LOG("MnRefProvider::SelectFromDialogL out");

}