/*

* Copyright (c) 2008 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:   This is the source file for the CClockWorldView class.

*

*/

// System includes

#include <aknViewAppUi.h>

#include <StringLoader.h>

#include <AknUtils.h>

#include <clock.rsg>

#include <aknnotewrappers.h>

#include <aknlists.h>

#include <tzlocalizer.h>

#include <tzlocalizationdatatypes.h>

#include <AknQueryDialog.h>

#include <MGFetch.h>

#include <hlplch.h>

// User includes

#include "clockworldview.h"

#include "clockworldcontainer.h"

#include "clockworldarray.h"

#include "clockcityselectionlist.h"

#include "clockdocument.h"

#include "clockappui.h"

#include "clock.h"

#include "clock.hrh"

#include "clockserverclt.h"

#include "clock_debug.h"

#include "clockworlditemprocessor.h"

// Constants

const TInt KSizeMaxCitiesText( 100 );

const TInt KNoCities( 0 );

const TInt KIntervalTime( 60000000 );

// Literals

_LIT( KClockCitySelectionDll, "clockcityselectionlist.dll" );

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

// CClockWorldView::NewL

// rest of the details are commented in the header

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

//

CClockWorldView* CClockWorldView::NewL()

    {

    __PRINTS( "CClockWorldView::NewL - Entry" );

    CClockWorldView* self = new ( ELeave ) CClockWorldView;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    __PRINTS( "CClockWorldView::NewL - Exit" );

    return self;

    }

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

// CClockWorldView::~CClockWorldView

// rest of the details are commented in the header

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

//

CClockWorldView::~CClockWorldView()

	{

	__PRINTS( "CClockWorldView::~CClockWorldView - Entry" );

	if( iWorldArray )

	    {

	    delete iWorldArray;

	    iWorldArray = NULL;

	    }

	if( iContainer )

	    {

	    ( AppUi() )->RemoveFromStack( iContainer );

	    delete iContainer;

	    iContainer = NULL;

	    }

	iClockCitySelector.Close();

	if( iMaxCitiesAdded )

		{

		delete iMaxCitiesAdded;

		iMaxCitiesAdded = NULL;

		}

	if( iTimer )

        {

        delete iTimer;

        iTimer = NULL;

        }

    if( iItemProcessor )

        {

        delete iItemProcessor;

        iItemProcessor = NULL;

        }

	__PRINTS( "CClockWorldView::~CClockWorldView - Exit" );

	}

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

// CClockWorldView::Id

// rest of the details are commented in the header

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

//

TUid CClockWorldView::Id() const

	{

	__PRINTS( "CClockWorldView::Id - Entry" );

	__PRINTS( "CClockWorldView::Id - Entry" );

	return KClockAppWorldViewId;

	}

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

// CClockWorldView::HandleCommandL

// rest of the details are commented in the header

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

//

void CClockWorldView::HandleCommandL( TInt aCommand )

	{

	__PRINTS( "CClockWorldView::HandleCommandL - Entry" );

	switch( aCommand )

		{

		case EClockWorldAddRegion:

		    {

		    // Add a city to the list.

			AddLocationL();

		    }

		    break;

		case EClockWorldMyRegion:

		    {

			//Single click integration

            // If current item is other than home location set it as new home

		    // location

		    if ( iContainer->ListBox()->CurrentItemIndex() > KZerothIndex )

                {

                SetHomeLocationL();

                }

		    }

		    break;

		case EClockWorldRemoveRegion:

		    {

		    // Remove the selected city from the list.

			RemoveLocationL();

		    }

		    break;

		case EClockWorldAddImage:

			{

			// Change the image.

			AddImageL();

			}

			break;

		case EClockWorldSettings:

		    {

		    // Let the appui handle the command.

		    AppUi()->HandleCommandL( EClockSettings );

		    }

		    break;

		case EAknCmdHelp:  //EClockWorldHelp:

		    {

		    // Launch world clock help. 

		    HlpLauncher::LaunchHelpApplicationL( iCoeEnv->WsSession(), iAvkonAppUi->AppHelpContextL() );

		    }

		    break;

		case EAknSoftkeyExit:

		    {

		    AppUi()->HandleCommandL( aCommand );

		    }

		    break;

		case EClockWorldExit:

		    {

		    AppUi()->HandleCommandL( aCommand );

		    }

		    break;

		case EAknCmdHideInBackground:

		    {

		    // Close the gallary, if open already.

		    if( iCanceler )

		        {

		        iCanceler->CancelFetcherL();

		        }

		    }

		    break;

		default:

			{

			// No impelementation yet.

			}

			break;

		}

	__PRINTS( "CClockWorldView::HandleCommandL - Exit" );

	}

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

// CClockWorldView::DynInitMenuPaneL

// rest of the details are commented in the header

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

//

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

    {

    __PRINTS( "CClockWorldView::DynInitMenuPaneL - Entry" );

	//Single click integration

    if( R_CLOCK_WORLD_VIEW_MENUPANE != aResourceId )

        {

        __PRINTS( "CClockWorldView::DynInitMenuPaneL - Exit" );

		// We're not bother about other menupanes.

        return;

        }

	// TODO: For help.

    /*if( !FeatureManager::FeatureSupported( KFeatureIdHelp ) )

        {       

        aMenuPane->DeleteMenuItem( EWorldClockHelp );      

        }*/

    if( KNoCities == iWorldArray->MdcaCount() )

        {

		//Single click integration

       	aMenuPane->SetItemDimmed( EClockWorldRemoveRegion, ETrue );  

        aMenuPane->SetItemDimmed( EClockWorldAddImage, ETrue );      	

       	aMenuPane->SetItemDimmed( EClockWorldMyRegion, ETrue );

        }

	// Add item is displayed only if the selection list is available.

	if( !iSelectionListAvailable )

        { 

        // Hide the Add menu option if loading DLL failed.

       	aMenuPane->SetItemDimmed( EClockWorldAddRegion, ETrue );

        }

	// Check if automatic-time update is On.

	RClkSrvInterface clockServerClt;

    // Connect to clockserver

    TInt errorVal( clockServerClt.Connect() );

    // Check if timeupdate is On.

    TBool timeUpdateOn( EFalse );

    if( KErrNone == errorVal )

        {

        errorVal = clockServerClt.IsAutoTimeUpdateOn( timeUpdateOn );

        }

    // Close the session with the server.

    clockServerClt.Close();

	if( KZerothIndex == iContainer->ListBox()->CurrentItemIndex() && !timeUpdateOn )

	    {

	    aMenuPane->DeleteMenuItem( EClockWorldMyRegion );

	    aMenuPane->DeleteMenuItem( EClockWorldAddImage );

	    aMenuPane->SetItemDimmed( EClockWorldRemoveRegion, ETrue);

	    }

    __PRINTS( "CClockWorldView::DynInitMenuPaneL - Exit" );

    }

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

// CClockWorldView::DynInitMenuBarL

// rest of the details are commented in the header

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

//

//single click integration

void CClockWorldView::DynInitMenuBarL( TInt /*aResourceId*/, CEikMenuBar* aMenuBar )

    {

    __PRINTS( "CClockWorldView::DynInitMenuBarL - Entry" );

	//single click integration

    if( aMenuBar && ( IsSelectionListOpen() || IsGalleryOpen() ) )

        {

        // If the selection list open, we should not display the menupane.

        aMenuBar->StopDisplayingMenuBar();

        }

    __PRINTS( "CClockWorldView::DynInitMenuBarL - Exit" );

    }

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

// CClockWorldView::GetApplicationRect

// rest of the details are commented in the header

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

//

TRect CClockWorldView::GetApplicationRect()

    {

    __PRINTS( "CClockWorldView::GetApplicationRect - Entry" );

    __PRINTS( "CClockWorldView::GetApplicationRect - Exit" );

    // Return the applicationrect from appui.

    return AppUi()->ApplicationRect();

    }

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

// CClockWorldView::HandleEnvChangeL

// rest of the details are commented in the header

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

//

void CClockWorldView::HandleEnvChangeL( TClockEnvChanged aEnvChanged )

    {

    __PRINTS( "CClockWorldView::HandleEnvChangeL - Entry" );

    CClockDocument* clockDocument = static_cast< CClockDocument* > ( AppUi()->Document() );

    // Here we check if the environment change was in the system time/zone,

    // we check if the current zone is different from the homecity item in the list

    // and if it is, then we update it with the new one.

    if( EEnvChanged == aEnvChanged && clockDocument->IsHomeCityItemAdded() )

        {

        // Remove the previous home city.

        iWorldArray->RemoveCity( KZerothIndex );

        // Add the current home city to the world clock view. 

        iWorldArray->InsertHomeCityItem();

        if( iContainer )

            {

            // We update the first item in the list.

            iContainer->ListBox()->HandleItemAdditionL();

            }

        }

    if( iContainer )

        {

        // Update the container.

        iContainer->Refresh();

        }

    __PRINTS( "CClockWorldView::HandleEnvChangeL - Exit" );

    }

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

// CClockWorldView::IsSelectionListOpen

// rest of the details are commented in the header

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

//

TBool CClockWorldView::IsSelectionListOpen()

    {

    __PRINTS( "CClockWorldView::IsSelectionListOpen - Entry" );

    __PRINTS( "CClockWorldView::IsSelectionListOpen - Exit" );

    return iSelectionListOpen;

    }

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

// CClockWorldView::IsGalleryOpen

// rest of the details are commented in the header

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

//

TBool CClockWorldView::IsGalleryOpen()

    {

    __PRINTS( "CClockWorldView::IsGalleryOpen - Entry" );

    __PRINTS( "CClockWorldView::IsGalleryOpen - Exit" );

    return iGalleryOpen;

    }

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

// CClockWorldView::TimerCallback

// rest of the details are commented in the header

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

//

TInt CClockWorldView::TimerCallback( TAny* aThis )

    {

    __PRINTS( "CClockWorldView::TimerCallback - Entry" );

    CClockWorldView* self( STATIC_CAST( CClockWorldView*, aThis ) );

    // Update the container.

    if( self->iContainer )

        {

        self->iContainer->Refresh();

        }

    TTime homeTime;

    homeTime.HomeTime();

    TDateTime dateTime( homeTime.DateTime() );

    if( 0 < dateTime.Second() )

        {

        self->iTimer->Cancel();

        self->iTimer->After( KIntervalTime - 1000000 * dateTime.Second() - dateTime.MicroSecond() );

        }

    __PRINTS( "CClockWorldView::TimerCallback - Exit" );

    return FALSE;

    }

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

// CClockWorldView::ClockApplicationUi

// rest of the details are commented in the header

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

//

CClockAppUi* CClockWorldView::ClockApplicationUi()

    {

    __PRINTS( "CClockWorldView::ClockApplicationUi - Entry" );

    return static_cast< CClockAppUi* > ( AppUi() );

    __PRINTS( "CClockWorldView::ClockApplicationUi - Exit" );

    }

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

// CClockWorldView::DoActivateL

// rest of the details are commented in the header

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

//

void CClockWorldView::DoActivateL( const TVwsViewId& /*aPrevViewId*/,

        					       TUid /*aCustomMessageId*/,

        					       const TDesC8& /*aCustomMessage*/ )

    {

    __PRINTS( "CClockWorldView::DoActivateL - Entry" );

    iItemToFocus = KZerothIndex;

    // Insert the homecity item in the list. We do this only if Automatic-time update is Off.

    RClkSrvInterface clockServerClt;

    // Connect to clockserver

    TInt errorVal( clockServerClt.Connect() );

    // Check if timeupdate is On.

    TBool timeUpdateOn( EFalse );

    if( KErrNone == errorVal )

        {

        errorVal = clockServerClt.IsAutoTimeUpdateOn( timeUpdateOn );

        }

    // Close the session with the server.

    clockServerClt.Close();

    CClockDocument* clockDocument = static_cast< CClockDocument* > ( AppUi()->Document() );

    if( !iContainer )

    	{

    	iContainer = CClockWorldContainer::NewL( this, ClientRect(), iWorldArray );

    	( AppUi() )->AddToStackL( *this, iContainer );

    	iContainer->SetMopParent( this );

    	// Create the CClockWorldItemProcessor object to redraw each listitem

    	iItemProcessor = CClockWorldItemProcessor::NewL( iContainer );

    	iWorldArray->SetItemProcessor( iItemProcessor );

        // If automatic time update is OFF then set the empty text to NULL and insert the home city.

        if( !timeUpdateOn )

            {

            iWorldArray->InsertHomeCityItem();

            clockDocument->SetHomeCityItemAdded( ETrue );

            // Update the listbox.

            iContainer->ListBox()->HandleItemAdditionL();

            }

        else 

            {

            clockDocument->SetHomeCityItemAdded( EFalse );

            }

    	}

    // This code will get executed, even if the container was constructed before, this code has to 

    // get executed to ensure correct text is displayed when the list is empty.

    // Check if automatic time update is ON and home city is added.

    // then remove the home city.

    if( timeUpdateOn )

        {

        // Check if home city is added.

        if( clockDocument->IsHomeCityItemAdded() )

            {

            iWorldArray->RemoveCity( KZerothIndex );

            clockDocument->SetHomeCityItemAdded( EFalse );

            iContainer->ListBox()->HandleItemRemovalL();

            }

        // Automatic time update is on.In case worldarray list is empty then display the no locations string. 

        if( !iWorldArray->MdcaCount() )

            {

            HBufC* noLocationBuf = StringLoader::LoadLC( R_WRLD_CLK_EMPTY_VIEW, iCoeEnv );

            iContainer->ListBox()->View()->SetListEmptyTextL( noLocationBuf->Des() );

            CleanupStack::PopAndDestroy( noLocationBuf );

            }

        }

    else

        {

        // Check if home city is not inserted.

        if( !clockDocument->IsHomeCityItemAdded() )

            {

            iWorldArray->InsertHomeCityItem();

            clockDocument->SetHomeCityItemAdded( ETrue );

            iContainer->ListBox()->HandleItemAdditionL();

            }

        // If automatic time update is OFF then set the empty text to NULL and insert the home city.

        HBufC* noLocationBuf = HBufC::NewLC( 1 );

        noLocationBuf->Des().Append( KSingleSpace );

        iContainer->ListBox()->View()->SetListEmptyTextL( noLocationBuf->Des() );

        CleanupStack::PopAndDestroy( noLocationBuf );

        }

    if( clockDocument->IsHomeCityItemAdded() )

        {

        // If home city is already added,