/*

* Copyright (c) 2005 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:  Provides Blid main view class methods.

*

*/

// INCLUDE FILES

#include <aknlists.h>

#include <AknQueryDialog.h> 

#include <StringLoader.h>

#include <eikmenub.h> // CEikMenuBar

#include <Blid.rsg>

#include <EPos_CPosLandmarkDatabase.h>

#include <EPos_CPosLmItemIterator.h>

#include <e32std.h>

#include <CLmkEditorDlg.h>

#include <TLmkItemIdDbCombiInfo.h>

#include <alf/alfimageloaderutil.h>

#include "CBlidBaseView.h"

#include "CBlidAppUi.h"

#include "CBlidBaseContainer.h"

#include "MBlidRouter.h"

#include "MBlidSettings.h"

#include "MBlidLocation.h"

#include "CBlidEng.h"

#include "CBlidDocument.h"

#include "Blid.hrh"

#include "bliduiconsts.h"

#include "CBlidCurrentPositionDlg.h"

#include <locationvariationdomaincrkeys.h>

#include <centralrepository.h>

enum TPanicCode

    {

    KBlidNullPointer = 1

    };

// Start with the assumption that PSY is not connected

TInt CBlidBaseView::iPSYTimeoutCount = 0;

TBool CBlidBaseView::iOnline = EFalse;

const TInt KMiddleSKId = 3;

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

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

// CBlidBaseView::CBlidBaseView

// First phase constructor, should not leave

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

//

CBlidBaseView::CBlidBaseView( MKeyProcessor& aKeyProcessor )

        : iKeyProcessor(aKeyProcessor)

    {

    StringLoader::Load( iManualWaypointName, R_BLID_DESTINATION_COORDINATES, iCoeEnv );

    }

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

// CBlidBaseView::BaseConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CBlidBaseView::BaseConstructL( TInt aResId )

    {

    FeatureManager::InitializeLibL();

    CAknView::BaseConstructL( aResId ); 

    iEngine = static_cast<CBlidDocument*>(AppUi()->Document())->Engine();

    if( !iEngine->LocationModel() )

	    {

    	iEngine->CreateModelL( CBlidEng::EBlidLocation );	    	

	    }

    iLocation = iEngine->LocationModel();

    __ASSERT_DEBUG( iLocation, User::Panic(_L("CBlidOwnPosView"),

        KBlidNullPointer));

    iRouter = iEngine->RouterModel(); 

    iImageLoaderUtil = new (ELeave) CAlfImageLoaderUtil();

	iConFileName.Zero();

	iConFileName.Append( _L("z") );

	iConFileName.Append( KBlidSystemIconPath );

	iIsSettingsViewActive = EFalse;   

    __ASSERT_DEBUG( iRouter, User::Panic(_L("CBlidOwnPosView"),

        KBlidNullPointer));

    }

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

// CBlidBaseView::~CLocBaseView()

// Destructor, frees allocated resources

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

//

CBlidBaseView::~CBlidBaseView()

    {

    FeatureManager::UnInitializeLib();

    delete iImageLoaderUtil;

    }

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

// CBlidBaseView::ProcessKeyEventL

// Processes the key event

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

//

TBool CBlidBaseView::ProcessKeyEventL( const TKeyEvent& aKeyEvent,

                                      TEventCode aType )

    {

    return iKeyProcessor.ProcessKeyEventL( aKeyEvent, aType );

    }

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

// CBlidBaseView::TabObserver()

// Returns the tab observer

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

//

MAknTabObserver* CBlidBaseView::TabObserver()

    {

    return iKeyProcessor.TabObserver();

    }

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

// CBlidBaseView::DynInitMenuPaneL

// Called to initialize the menu pane at run time

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

//

void CBlidBaseView::DynInitMenuPaneL(

    TInt aResourceId, CEikMenuPane* aMenuPane )

    {

    #ifdef _DEBUG

    RDebug::Print(_L("CBlidCompassView::DynInitMenuPaneL() called"));

    #endif

    switch( aResourceId )

        { 

        case R_BLID_VIEW_MENU:

        {

            if ( !(iLocation->IsGPSDataAvailable() && 

                   iLocation->SatelliteCapability()) )

                {                

                aMenuPane->SetItemDimmed( EBlidCmdSatelliteStatus, ETrue );                

                }

             if ( (!iRouter->Count()) || FeatureManager::FeatureSupported( KFeatureIdLandmarks ) )

                {

                aMenuPane->SetItemDimmed( EBlidCmdSavedWaypoints, ETrue );

                }

            // hide the save position.

            if(!iLocation->IsOnline())

                {

                aMenuPane->SetItemDimmed( EBlidCmdCurrentLocation, ETrue );

                }

        }

                //-fallthrough

        case R_BLID_VIEW_OK_MENU:        

            {      

            if ( !iRouter->IsAnyPointSet() )

                {

                aMenuPane->SetItemDimmed( EBlidCmdStopNavigation, ETrue );

                }                

            break;

            }

        case R_BLID_MAIN_MENU:

            {

            CBlidBaseView::HandleHelpFeature( aMenuPane );

            break;

            }

        case R_BLID_SET_DESTINATION_MENU:

			{

			if ( iRouter->Count() <= 0 )

				{

				aMenuPane->SetItemDimmed( EBlidCmdWaypoint, ETrue );

				}                

			else

				{

				aMenuPane->SetItemDimmed( EBlidCmdWaypoint, EFalse );	

				}

			// Features manager checks for waypoint/landmarks variation

			if ( FeatureManager::FeatureSupported( KFeatureIdLandmarks ) )

				{

				aMenuPane->SetItemDimmed( EBlidCmdWaypoint, ETrue );				

				}

			else

				{

				aMenuPane->SetItemDimmed( EBlidCmdLmk, ETrue );

				}

			if ( FeatureManager::FeatureSupported( KFeatureIdLandmarks ) )

			    {

    			if( IsLmAvailableL() )

    				{

    				aMenuPane->SetItemDimmed( EBlidCmdLmk, EFalse );

    				}

    			else

    				{

    				aMenuPane->SetItemDimmed( EBlidCmdLmk, ETrue );

    				}		

    			}

    			break;

			} 

        case R_BLID_SAVE_CURRENT_LOCATION_MENU:

        {

        	TInt settingsValue = 0;

            CRepository* repository = CRepository::NewL( TUid::Uid( KCRUidLocLocalVariation) );

            CleanupStack::PushL( repository );

            User::LeaveIfError( repository->Get( KLocHideCoordinates,

                                                      settingsValue ));  

            CleanupStack::PopAndDestroy( repository );

            if ( ELocCoordinatesHidden == settingsValue )

            {

            	 aMenuPane->SetItemDimmed( EBlidCmdShowDetails, ETrue );

            }

            else

            {

             	 aMenuPane->SetItemDimmed( EBlidCmdShowDetails, EFalse );

            }

            break;

        } 

        default:

            {

            break;

            }

        }

    }

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

// CBlidBaseView::NotifyL

// Called by location model to notify about updates in location

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

//

void CBlidBaseView::NotifyL( const TBool /*aOnlineMode*/ )

    {  

    if( iPopupDialog )

	    {

		iPopupDialog->ChangeDlgSoftKey();	    	

	    }      

    // GPS available    

    CBlidBaseContainer::SetGPSAvailability(ETrue);

    }

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

// CBlidBaseView::NotifyError

// Called by location model to notify about error in location

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

//

void CBlidBaseView::NotifyErrorL( TInt /*aErrorCode*/ )

    {

    if( iPopupDialog )

	    {

		iPopupDialog->ChangeDlgSoftKey();	    	

	    }

    }

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

// CBlidBaseView::HandleHelpFeature

// Handles the Help option command

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

//

void CBlidBaseView::HandleHelpFeature( CEikMenuPane* aMenuPane ) const

    {

    //implementation for req 406-917. Hide position view based on feature variation flag

    TInt helpSettingValue = ELocHelpNotHidden;

    CRepository* repository = CRepository::NewL( TUid::Uid( KCRUidLocLocalVariation) );

    CleanupStack::PushL( repository );

     User::LeaveIfError( repository->Get( KLocHideHelp,

                                              helpSettingValue ));  

    CleanupStack::PopAndDestroy( repository );

    if ( FeatureManager::FeatureSupported( KFeatureIdHelp ) && !helpSettingValue)

        {

        aMenuPane->SetItemDimmed( EAknCmdHelp, EFalse );

        }

    else

        {

        aMenuPane->SetItemDimmed( EAknCmdHelp, ETrue );

        }

    }

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

// CBlidBaseView::InsertWaypointL

// Insers a waypoint

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

//

TBool CBlidBaseView::InsertWaypointL()

    {

    TInt index(KErrCancel);

    TBuf<KBlidWaypointNameMaxLen> textData;

    StringLoader::Load( textData, R_BLID_WAYPOINT_NAME, iCoeEnv );

    TInt errorCode(KErrNone);	

    TBool returnValue(ETrue);

    TInt removedIndex;

    do

        {

        if(errorCode != KErrNone)

        	{

        	return EFalse;

        	}

        CAknTextQueryDialog* dlg = new(ELeave) CAknTextQueryDialog(textData,

                                                    CAknQueryDialog::ENoTone);

        if (!dlg->ExecuteLD(R_BLID_WAYPOINT_QUERY))

            {

            return EFalse;           

            }

        }while( CheckIfExistL( textData, errorCode, removedIndex ) );

        if(errorCode != KErrNone)

        	{

        	return EFalse;

        	}

        /// if KMaxNumberOfWaypoints or more than that is already present

        /// display note.

        if ( iRouter->Count() >= KMaxNumberOfWaypoints )

            {

            static_cast<CBlidAppUi*>(AppUi()

                )->ShowDialogL( BlidNotes::EBlidOverWriteWaypointNote );            

            return EFalse;            

            }    

        TInt retVal(KErrNone);

        if ( index >=0 )

            {

            if ( iRouter->IndexOfWaypoint() >=0 && 

                 index >= iRouter->IndexOfWaypoint() )

                {                

                index++;

                }

            retVal = iRouter->RemoveL( index );

            if(retVal == KErrDiskFull)

	        	{

	        	BlidNotes::OutOfMemoryNoteL();

	        	}

            }

        if(retVal == KErrNone)

        	{

        	TNamedCoordinate* waypoint = new(ELeave)TNamedCoordinate();

	        CleanupStack::PushL( waypoint );

	        waypoint->SetName( textData );

	        TPosition position = iLocation->GetCurrentPosition();

	        waypoint->SetCoordinate( position.Latitude(),

	                                 position.Longitude(),

	                                 position.Altitude() );

	        position.SetHorizontalAccuracy(position.HorizontalAccuracy());

	        waypoint->SetAccuracy(position.HorizontalAccuracy());

	        //iRouter takes waypoint's ownership

	        TInt retVal = iRouter->AppendL( waypoint, ETrue);

	        if(retVal == KErrDiskFull)

	        	{

	        	delete waypoint;

	        	BlidNotes::OutOfMemoryNoteL();

	        	returnValue = EFalse;

	        	}

	        CleanupStack::Pop(); //waypoint

        	}                

        return returnValue;

        }

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

// CBlidBaseView::SelectWaypoint

// Select a waypoint

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

//

TInt CBlidBaseView::SelectWaypointL()

    {

    TInt index(KErrCancel);   

    TInt currentIndex(0);     

    CEikFormattedCellListBox* listBox = 

        new(ELeave)CAknSinglePopupMenuStyleListBox;

    CleanupStack::PushL( listBox );    

    HBufC* name = NULL;

    TInt count( iRouter->Count() );

    TNamedCoordinate* waypoint = iRouter->Waypoint();

    CDesCArray* array = new(ELeave)CDesCArrayFlat(KMaxNumberOfWaypoints);

    CleanupStack::PushL( array );

    TInt waypointAdditionCount = 0;

	// fill up the array with waypoint's names from the engine.

	for ( TInt i = 0; i < count; i++ )

        {

        name = iRouter->At(i).Name();

        if ( name )

            {

            CleanupStack::PushL( name );

		    array->AppendL( *name );

		    waypointAdditionCount ++;

		    CleanupStack::PopAndDestroy(name); //name

            }

        else

        	{

        	currentIndex = i;

        	}

        }

    CAknPopupList* popupList = CAknPopupList::NewL( listBox,

        R_AVKON_SOFTKEYS_OK_CANCEL,

        AknPopupLayouts::EPopupSNotePopupWindow);

    CleanupStack::PushL(popupList);

    HBufC* title = iCoeEnv->AllocReadResourceLC( R_BLID_QUERY_WAYPOINT );

    popupList->SetTitleL( *title );

    CleanupStack::PopAndDestroy(title); //title    

    title = NULL;

    listBox->ConstructL( popupList, 

        EAknListBoxSelectionList | EAknListBoxLoopScrolling);

    listBox->CreateScrollBarFrameL(ETrue); 

    listBox->ScrollBarFrame()->SetScrollBarVisibilityL( 

                                CEikScrollBarFrame::EAuto, 

                                CEikScrollBarFrame::EAuto);

    //listbox's model take ownership of array

    listBox->Model()->SetItemTextArray(array);

    CleanupStack::Pop(popupList); // popupList

    CleanupStack::Pop(array); //array 

    TBool isEmpty = array->Count() == 0;

    if ( popupList->ExecuteLD()  ) 

        {

        index = listBox->CurrentItemIndex();

        }

    CleanupStack::PopAndDestroy(listBox); //listBox

    if(isEmpty)

    	{

    	return KErrCancel;

    	}

    if(waypoint && waypointAdditionCount != iRouter->Count())   

    	{

    	if(index >= currentIndex)

    		{

    		index += 1;    				

    		}        

    	}

    if ( index != KErrCancel )

    	{

    	TNamedCoordinate waypoint = iRouter->At(index);

    	if(waypoint.Accuracy() >= KBlidPoorAccuracy)

    		{

    		HBufC* noteText = StringLoader::LoadLC( R_BLID_CONF_DEST_INACCURATE , iCoeEnv );	        		

    		CAknQueryDialog* dlg = CAknQueryDialog::NewL(CAknQueryDialog::ENoTone);

    		if(dlg->ExecuteLD(R_BLID_CONFIRMATION_QUERY, *noteText))

    			{

    			CleanupStack::PopAndDestroy( noteText );

    			return index;

    			}

    		else

    			{

    			CleanupStack::PopAndDestroy( noteText );

    			return KErrCancel;

    			}

    		}

    	}

    return index;

    }

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

// CBlidBaseView::CheckIfExist

// Checks if a waypoint exists

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

//

TBool CBlidBaseView::CheckIfExistL( const TDes& aName, TInt& aErrorCode, TInt& aRemovedIndex )

    {

    TInt i(0);

    TInt count( iRouter->Count() );

    HBufC* name = NULL;

    TBool retVal;

	aRemovedIndex = KErrNotFound;

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

        {

        name = iRouter->At( i ).Name();

        if ( name && name->Compare( aName ) == 0 )

            {

            CleanupStack::PushL(name);

            HBufC* text;

            text = StringLoader::LoadLC(R_BLID_QUERY_WAYPOINT_NAME_EXISTS,

                                       *name,

                                       iCoeEnv);

            CAknQueryDialog* dlg = CAknQueryDialog::NewL();

            CleanupStack::PushL(dlg);

            dlg->SetPromptL( *text ); 

            CleanupStack::Pop( dlg );           

            retVal = dlg->ExecuteLD(R_BLID_CONFIRMATION_QUERY);            

            if(retVal)

                {

                TInt retVal = iRouter->RemoveL(i);

				aRemovedIndex = i;

                if(retVal == KErrDiskFull)

		        	{

		        	aErrorCode = KErrDiskFull;

		        	BlidNotes::OutOfMemoryNoteL();

		        	}