/*

* 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 CClockMainContainer class.

*

*/

// System includes

#include <AknsBasicBackgroundControlContext.h>

#include <AknsSkinInstance.h>

#include <AknsUtils.h>

#include <AknsDrawUtils.h>

#include <AknSkinnableClock.h>

#include <csxhelp/clk.hlp.hrh>

#include <aknlayoutscalable_apps.cdl.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <layoutmetadata.cdl.h>

#include <clock.rsg>

#include <StringLoader.h>

#include <aknlists.h>

#include <gulicon.h>

#include <AknIconArray.h>

#include <AknsConstants.h>

#include <AknDef.h>

#include <clockapp.mbg>

#include <avkon.mbg>

#include <tz.h>

#include <tzlocalizer.h>

#include <tzlocalizationdatatypes.h>

#include <vtzrules.h>

#include <aknbutton.h>

// User includes

#include "clockmaincontainer.h"

#include "clockmainview.h"

#include "clockalarmarray.h"

#include "clockserverclt.h"

#include "clockmarqueelabel.h"

#include "clkcommon.h"

#include "clock.hrh"

#include "clock.h"

#include "clock_debug.h"

#include "clockappui.h"

// Constants

const TInt KNumOfIcons( 3 );

const TInt KHour( 60 );

const TInt KZerothRule( 0 );

const TInt KOffsetStringLength( 64 );

const TInt KLocationNameLength( 100 );

const TInt KDayNames[] =

    {

    R_QTN_WEEK_LONG_MONDAY,

    R_QTN_WEEK_LONG_TUESDAY,

    R_QTN_WEEK_LONG_WEDNESDAY,

    R_QTN_WEEK_LONG_THURSDAY,

    R_QTN_WEEK_LONG_FRIDAY,

    R_QTN_WEEK_LONG_SATURDAY,

    R_QTN_WEEK_LONG_SUNDAY

    };

TInt const KSwitchDelay = 200*1000;

// Literals

_LIT( KIconFileName, "\\resource\\apps\\clockapp.mif" );

_LIT( KPlusGMT, " \x202A+" );

_LIT( KMinusGMT, " \x202A" );

_LIT( KPDF, " \x202C" );

_LIT( KZero, "0" );

_LIT( KSpace, " " );

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

// CClockMainContainer::NewL

// rest of the details are commented in the header

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

//

CClockMainContainer* CClockMainContainer::NewL( CClockMainView* aView, const TRect& aRect, CClockAlarmArray* aAlarmArray )

    {

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

    CClockMainContainer* self = new ( ELeave ) CClockMainContainer;

    CleanupStack::PushL( self );

    self->ConstructL( aView, aRect, aAlarmArray );

    CleanupStack::Pop( self );

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

    return self;

    }

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

// CClockMainContainer::~CClockMainContainer

// rest of the details are commented in the header

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

//

CClockMainContainer::~CClockMainContainer()

    {

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

	if( iBgContext )

	    {

	    delete iBgContext;

	    iBgContext = NULL;

	    }

	if( iSkinnableClock )

	    {

	    delete iSkinnableClock;

	    iSkinnableClock = NULL;

	    }

	if( iListBox )

	    {

	    delete iListBox;

	    iListBox = NULL;

	    }

	if( iDateString )

	    {

	    delete iDateString;

	    iDateString = NULL;

	    }

	if( iDstIndicator )

	    {

	    delete iDstIndicator;

	    iDstIndicator = NULL;

	    }

	if( iDstIndicatorMask )

	    {

	    delete iDstIndicatorMask;

	    iDstIndicatorMask = NULL;

	    }

	if( iDayNameString )

        {

        delete iDayNameString;

        iDayNameString = NULL;

        }

	if( iLocationString )

	    {

	    delete iLocationString;

	    iLocationString = NULL;

	    }

	if( iLocationLabel )

	    {

	    delete iLocationLabel;

	    iLocationLabel = NULL;

	    }

	if( iTimeZoneString )

	    {

	    delete iTimeZoneString;

	    iTimeZoneString = NULL;

	    }

	delete iNewAlarmButton;

	iNewAlarmButton = NULL;

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

    }

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

// CClockMainContainer::OfferKeyEventL

// rest of the details are commented in the header

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

//    

TKeyResponse CClockMainContainer::OfferKeyEventL( const TKeyEvent& aKeyEvent, 

                                                  TEventCode aType )

    {

	__PRINTS( "CClockMainContainer::OfferKeyEventL - Entry" );

    TKeyResponse retVal( EKeyWasNotConsumed );

    if( EEventKey == aType )

        {

        if( EStdKeyNo == aKeyEvent.iScanCode )

            {

            // This indicates that Call End key was pressed.

            // The timer is stopped and app is hidden in the background.

            iView->ClockApplicationUi()->HandleCommandL( EClockMainViewExit );

            retVal = EKeyWasConsumed;

            __PRINTS( "CClockMainContainer::OfferKeyEventL - Exit" );

            return retVal;

            }

        if( EKeyUpArrow == aKeyEvent.iCode ||

            EKeyDownArrow == aKeyEvent.iCode )

            {

            TInt itemCount = iListBox->Model()->ItemTextArray()->MdcaCount();

            // if neither has focus just then select button to be focused

            if( !iNewAlarmButton->IsFocused() && !iListBox->IsFocused() )

                {

                iListBox->View()->ItemDrawer()->SetFlags( CListItemDrawer::EDisableHighlight );

                iNewAlarmButton->SetFocus( ETrue );

                DrawDeferred();

                retVal = EKeyWasConsumed;

                }

            // button not focused and no list items -> set focus to button

            else if( itemCount == 0 && !iNewAlarmButton->IsFocused() )

                {

                iListBox->View()->ItemDrawer()->SetFlags( CListItemDrawer::EDisableHighlight );

                iListBox->SetFocus( EFalse );

                iNewAlarmButton->SetFocus( ETrue );

                DrawDeferred();

                retVal = EKeyWasConsumed;

                }

            // button focused and listbox has items

            else if( iNewAlarmButton->IsFocused() && itemCount > 0 )

                {

                iListBox->View()->ItemDrawer()->ClearFlags( CListItemDrawer::EDisableHighlight );

                iNewAlarmButton->SetFocus( EFalse );

                iListBox->SetFocus( ETrue );

                if( EKeyDownArrow == aKeyEvent.iCode )

                    {

                    iListBox->SetCurrentItemIndex( itemCount - 1 );

                    }

                else

                    {

                    iListBox->SetCurrentItemIndex( 0 );

                    }

                retVal = iListBox->OfferKeyEventL( aKeyEvent, aType );

                }

            // listbox focused

            else if( iListBox->IsFocused() && itemCount > 0 )

                {

                // first item when only one item in the list

                if( iListBox->CurrentItemIndex() == 0 && itemCount == 1 )

                    {

                    iListBox->View()->ItemDrawer()->SetFlags( CListItemDrawer::EDisableHighlight );

                    iListBox->SetFocus( EFalse );

                    iNewAlarmButton->SetFocus( ETrue );

                    DrawDeferred();

                    retVal = EKeyWasConsumed;

                    }

                // first item

                else if( iListBox->CurrentItemIndex() == 0 && EKeyUpArrow == aKeyEvent.iCode )

                    {

                    iListBox->View()->ItemDrawer()->SetFlags( CListItemDrawer::EDisableHighlight );

                    iListBox->SetFocus( EFalse );

                    iNewAlarmButton->SetFocus( ETrue );

                    DrawDeferred();

                    retVal = EKeyWasConsumed;

                    }

                //last item

                else if( iListBox->CurrentItemIndex() == ( itemCount - 1 )

                        && EKeyDownArrow == aKeyEvent.iCode )

                    {

                    iListBox->View()->ItemDrawer()->SetFlags( CListItemDrawer::EDisableHighlight );

                    iListBox->SetFocus( EFalse);

                    iNewAlarmButton->SetFocus( ETrue );

                    DrawDeferred();

                    retVal = EKeyWasConsumed;

                    }

                // Send the event to the listbox to handle the event.

                else

                    {

                    iListBox->View()->ItemDrawer()->ClearFlags( CListItemDrawer::EDisableHighlight );

                    retVal = iListBox->OfferKeyEventL( aKeyEvent, aType );

                    }

                }

            }

        if( ( EKeyBackspace == aKeyEvent.iCode || EKeyDelete == aKeyEvent.iCode ) &&

            ( KZeroAlarms < iListBox->Model()->ItemTextArray()->MdcaCount() ) )

            {

            // Handle backspace command. Deletes the selected alarm.

			//Single click integration

            if ( iListBox->IsFocused() && iView->MenuBar()->ItemSpecificCommandsEnabled() )

                {

                // if highlighted

                iView->HandleCommandL( EClockRemoveAlarm );

                retVal = EKeyWasConsumed;

                }

            // otherwise do nothing and don't consume key

            }

		//Single click integration

        if ( aKeyEvent.iCode == EKeyOK || aKeyEvent.iCode == EKeyEnter )

            {

            // Send the event to the listbox to handle the event

            // if listbox is focused

            if( iListBox->IsFocused() && iListBox->Model()->ItemTextArray()->MdcaCount() > 0 )

                {

                iListBox->OfferKeyEventL( aKeyEvent, aType );

                retVal = EKeyWasConsumed;

                }

            else

                {

                // default action for the enter is button press

                TKeyEvent keyEvent;

                keyEvent.iCode = EKeyOK;  

                keyEvent.iScanCode = EStdKeyDevice3;

                keyEvent.iModifiers = 0;

                keyEvent.iRepeats = 0;

                iNewAlarmButton->OfferKeyEventL( keyEvent, EEventKeyDown );

                iNewAlarmButton->OfferKeyEventL( keyEvent, EEventKey );

                iNewAlarmButton->OfferKeyEventL( keyEvent, EEventKeyUp );

                retVal = EKeyWasConsumed;

                }

            }

        }

	__PRINTS( "CClockMainContainer::OfferKeyEventL - Exit" );

    return retVal;

    }

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

// CClockMainContainer::Draw

// rest of the details are commented in the header

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

//

void CClockMainContainer::Draw( const TRect& aRect ) const

    {

	__PRINTS( "CClockMainContainer::Draw - Entry" );

    CWindowGc& windowGc = SystemGc();

    windowGc.Clear( aRect );

    if( iBgContext )

        {

        MAknsSkinInstance* skinInstance = AknsUtils::SkinInstance();

        AknsDrawUtils::Background( skinInstance, iBgContext, this, windowGc, aRect );

        }

    // Draw the date and day text.

    DrawMainViewText( windowGc );

    // TODO: Change the LCT when the new LCT data is available.

    // Check if the DST is ON. If so, display the DST indicator icon.

    if( iDSTOn )

        {

        TAknLayoutRect dstIndicatorRect;

        if( Layout_Meta_Data::IsLandscapeOrientation() )

            {

            dstIndicatorRect.LayoutRect( Rect(),

                                         AknLayoutScalable_Apps::main_clock2_pane_g1( KVGALandscapeVariant ).LayoutLine() );

            }

        else

            {

            dstIndicatorRect.LayoutRect( Rect(),

                                         AknLayoutScalable_Apps::main_clock2_pane_g1( KVGAPortraitVariant ).LayoutLine() );

            }

        AknIconUtils::SetSize( iDstIndicator, dstIndicatorRect.Rect().Size() );

        dstIndicatorRect.DrawImage( windowGc, iDstIndicator, iDstIndicatorMask );

        }

	__PRINTS( "CClockMainContainer::Draw - Exit" );

    }

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

// CClockMainContainer::FocusChanged

// rest of the details are commented in the header

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

//

void CClockMainContainer::FocusChanged( TDrawNow /*aDrawNow*/ )

    {

	__PRINTS( "CClockMainContainer::FocusChanged - Entry" );

	__PRINTS( "CClockMainContainer::FocusChanged - Exit" );

    }

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

// CClockMainContainer::HandlePointerEventL

// rest of the details are commented in the header

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

//

void CClockMainContainer::HandlePointerEventL( const TPointerEvent& aPointerEvent )

    {

	__PRINTS( "CClockMainContainer::HandlePointerEventL - Entry" );

    // Check first wheather touch is supported or not.

    if( !AknLayoutUtils::PenEnabled() )

        {

		__PRINTS( "CClockMainContainer::HandlePointerEventL - Exit" );

        return;

        }

    // to highlight the item in alarm list after long tapping

    //( when new alarm button is focused)

    if( iListBox && iListBox->Rect().Contains( aPointerEvent.iPosition ) &&

            aPointerEvent.iType == TPointerEvent::EButton1Down &&

            !iListBox->IsFocused() && iListBox->IsVisible() )

        {

        iListBox->View()->ItemDrawer()->ClearFlags( CListItemDrawer::EDisableHighlight );

        }

    // to get the vibes let's handle skinnable clock as a special case

    // no need to to delegate pointer events to it

    if( iSkinnableClock && iSkinnableClock->Rect().Contains( aPointerEvent.iPosition ) )

        {

        if( aPointerEvent.iType == TPointerEvent::EButton1Down  )

            {

            TTime now;

            now.HomeTime();

            TInt64 launchFreq = now.MicroSecondsFrom( iPreviousClockTypeSwitch ).Int64();

            if( launchFreq > MAKE_TINT64( 0, KSwitchDelay )  )

                {

                iView->GiveVibes();

                iView->HandleCommandL( EClockSwitchClockType ); 

                iPreviousClockTypeSwitch.HomeTime();

                }   

            }

        else

            {

            CCoeControl::HandlePointerEventL( aPointerEvent );

            }

        } 

    else

        {

        CCoeControl::HandlePointerEventL( aPointerEvent );

        }

	__PRINTS( "CClockMainContainer::HandlePointerEventL - Exit" );

    }

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

// CClockMainContainer::HandleListBoxEventL

// rest of the details are commented in the header

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

//

void CClockMainContainer::HandleListBoxEventL( CEikListBox* aListBox, TListBoxEvent aEventType )

    {

    __PRINTS( "CClockMainContainer::HandleListBoxEventL - Entry" );

    if( aListBox == iListBox &&

        ( aEventType == EEventItemSingleClicked || aEventType == EEventEnterKeyPressed ) )

        {

        // Check if the user has double clicked on the list item.

        if( !iView->IsAlarmEditorOpen() )

            {

            iView->HandleCommandL( EClockResetAlarm ); 

            }

        }

    __PRINTS( "CClockMainContainer::HandleListBoxEventL - Entry" );

    }

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

// CClockMainContainer::UpdateAlarmListL

// rest of the details are commented in the header

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

//

void CClockMainContainer::UpdateAlarmListL( SClkAlarmInfo& /*aAlarmInfo*/, TAlarmId aAlarmId )

    {

	__PRINTS( "CClockMainContainer::UpdateAlarmListL - Entry" );

    // Reinitialize the alarm id array.

    iAlarmArray->InitIdList();

    iListBox->HandleItemAdditionL();

    // Get the index of the new alarm added.

    TInt itemIndex( iAlarmArray->ListBoxIndex( aAlarmId ) );

    // Update the listbox.

    iListBox->ScrollToMakeItemVisible( itemIndex );

    iListBox->SetCurrentItemIndexAndDraw( itemIndex );

    SetCorrectRectForNewAlarmButton();

    iNewAlarmButton->DrawDeferred();

	__PRINTS( "CClockMainContainer::UpdateAlarmListL - Exit" );

    }

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

// CClockMainContainer::RemoveAlarmL

// rest of the details are commented in the header

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

//

void CClockMainContainer::RemoveAlarmL( TInt aIndex )

    {

	__PRINTS( "CClockMainContainer::RemoveAlarmL - Entry" );

    // Reinitialize the alarm list.

    iAlarmArray->InitIdList();

    TInt count = iListBox->Model()->ItemTextArray()->MdcaCount();

    // if only one item

    if( ( KZeroAlarms == aIndex ) && ( aIndex == count ) )

        {

        iListBox->SetCurrentItemIndex( KZeroAlarms );

        SetCorrectRectForNewAlarmButton();

        }  

    // last item when more than one exists

    else if( ( KZeroAlarms < aIndex ) && ( aIndex == count ) )

        {

        // Last alarm in the list is deleted hence set the previous alarm.

        iListBox->ScrollToMakeItemVisible( aIndex - 1 );

        iListBox->SetCurrentItemIndexAndDraw( aIndex - 1 );

        iListBox->HandleItemRemovalL();

        DrawNow();

        }

    // not last item