/*

* Copyright (c) 2007-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:  ESMR time (start-end) field implementation

 *

*/

#include "emailtrace.h"

#include "cesmrtimefield.h"

#include <eikmfne.h>

#include <avkon.hrh>

#include <eiklabel.h>

#include <AknUtils.h>

#include <AknsFrameBackgroundControlContext.h>

#include <AknsDrawUtils.h>

#include "mesmrfieldvalidator.h"

#include "cesmrglobalnote.h"

//<cmail>

#include "esmrdef.h"

//</cmail>

#include "esmrfieldbuilderdef.h"

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

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

// CESMRTimeField::CESMRTimeField

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

//

CESMRTimeField::CESMRTimeField( )

    {

    FUNC_LOG;

    // do nothing

    }

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

// CESMRTimeField::~CESMRTimeField

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

//

CESMRTimeField::~CESMRTimeField( )

    {

    FUNC_LOG;

    // iContainer is deleted by framework

    // do nothing

    }

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

// CESMRTimeField::NewL

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

//

CESMRTimeField* CESMRTimeField::NewL(

        MESMRFieldValidator* aValidator )

    {

    FUNC_LOG;

    CESMRTimeField* self = new (ELeave) CESMRTimeField;

    CleanupStack::PushL ( self );

    self->ConstructL ( aValidator );

    CleanupStack::Pop ( self );

    return self;

    }

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

// CESMRTimeField::ConstructL

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

//

void CESMRTimeField::ConstructL(

        MESMRFieldValidator* aValidator )

    {

    FUNC_LOG;

    SetFieldId ( EESMRFieldMeetingTime );

    iContainer =

            CTimeContainer::NewL(

                    aValidator,

                    this,

                    EESMRFieldMeetingTime );

    CESMRIconField::ConstructL(

            KAknsIIDQgnMeetReqIndiClock,

            iContainer );

    }

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

// CESMRTimeField::SetContainerWindowL

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

//

void CESMRTimeField::SetContainerWindowL(

        const CCoeControl& aControl )

    {

    FUNC_LOG;

    CCoeControl::SetContainerWindowL ( aControl );

    if ( iContainer )

        {

        iContainer->SetContainerWindowL ( aControl );

        }

    }

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

// CESMRTimeField::OfferKeyEventL

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

//

TKeyResponse CESMRTimeField::OfferKeyEventL(

        const TKeyEvent& aEvent,

        TEventCode aType )

    {

    FUNC_LOG;

    TKeyResponse response( EKeyWasNotConsumed);

    if ( iContainer )

        {

        response = iContainer->OfferKeyEventL ( aEvent, aType );

        }

    return response;

    }

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

// CESMRTimeField::InitializeL

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

//

void CESMRTimeField::InitializeL()

    {

    FUNC_LOG;

    if ( iContainer )

        {

        iContainer->SetFontL( iLayout->Font ( iCoeEnv, iFieldId ), iLayout );

        }

    }

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

// CESMRTimeField::OkToLoseFocusL

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

//

TBool CESMRTimeField::OkToLoseFocusL(

        TESMREntryFieldId aNext )

    {

    FUNC_LOG;

    if ( iContainer )

        {

        return iContainer->OkToLoseFocusL ( FieldId ( ), aNext );

        }

    return EFalse;

    }

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

// CESMRTimeField::SetOutlineFocusL

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

//

void CESMRTimeField::SetOutlineFocusL( TBool aFocus )

    {

    FUNC_LOG;

    CESMRField::SetOutlineFocusL ( aFocus );

    if ( aFocus )

        {

        ChangeMiddleSoftKeyL(EESMRCmdSaveMR,R_QTN_MSK_SAVE);

        }

    }

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

// CTimeContainer::CTimeContainer

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

//

CTimeContainer::CTimeContainer(

        MESMRFieldValidator* aValidator,

        TESMREntryFieldId aFieldId  ) :

    iValidator(aValidator),

    iFieldId( aFieldId )

    {

    FUNC_LOG;

    // do nothing

    }

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

// CTimeContainer::~CTimeContainer

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

//

CTimeContainer::~CTimeContainer( )

    {

    FUNC_LOG;

    delete iStartTime;

    delete iEndTime;

    delete iSeparator;

    delete iStartTimeBgContext;

    delete iEndTimeBgContext;

    }

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

// CTimeContainer::NewL

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

//

CTimeContainer* CTimeContainer::NewL(

        MESMRFieldValidator* aValidator,

        CCoeControl* aParent,

        TESMREntryFieldId aFieldId )

    {

    FUNC_LOG;

    CTimeContainer* self =

            new (ELeave) CTimeContainer( aValidator, aFieldId );

    CleanupStack::PushL ( self );

    self->ConstructL ( aParent );

    CleanupStack::Pop ( self );

    return self;

    }

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

// CTimeContainer::ConstructL

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

//

void CTimeContainer::ConstructL(

        CCoeControl* /*aParent*/)

    {

    FUNC_LOG;

    TTime startTime;

    startTime.UniversalTime ( );

    iStartTime = new (ELeave) CEikTimeEditor;

    iEndTime = new (ELeave) CEikTimeEditor;

    iSeparator = new (ELeave) CEikLabel;

    iStartTime->ConstructL ( TTIME_TIMEFIELDMINIMUMDATE, 

                             TTIME_TIMEFIELDMAXIMUMDATE,

                             startTime, 

                             EEikTimeWithoutSecondsField );

    iEndTime->ConstructL ( TTIME_TIMEFIELDMINIMUMDATE, 

                           TTIME_TIMEFIELDMAXIMUMDATE,

                           startTime, 

                           EEikTimeWithoutSecondsField );

    iBackground = AknsDrawUtils::ControlContext( this );

    TInt align = CESMRLayoutManager::IsMirrored ( ) ? EAknEditorAlignRight

            : EAknEditorAlignLeft;

    iStartTime->SetMfneAlignment ( align );

    iEndTime->SetMfneAlignment ( align );

    iSeparator->SetTextL ( KTimeFieldSeparator );

    if ( iValidator )

        {

        iValidator->SetStartTimeFieldL( *iStartTime );

        iValidator->SetEndTimeFieldL( *iEndTime );

        }

    }

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

// CTimeContainer::SetContainerWindowL

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

//

void CTimeContainer::SetContainerWindowL(

        const CCoeControl& aControl )

    {

    FUNC_LOG;

    CCoeControl::SetContainerWindowL ( aControl );

    iStartTime->SetContainerWindowL ( aControl );

    iEndTime->SetContainerWindowL ( aControl );

    }

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

// CTimeContainer::CountComponentControls

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

//

TInt CTimeContainer::CountComponentControls() const

    {

    FUNC_LOG;

    TInt count( 0);

    if ( iStartTime )

        {

        ++count;

        }

    if ( iSeparator )

        {

        ++count;

        }

    if ( iEndTime )

        {

        ++count;

        }

    return count;

    }

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

// CTimeContainer::ComponentControl

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

//

CCoeControl* CTimeContainer::ComponentControl(

        TInt aInd ) const

    {

    FUNC_LOG;

    switch ( aInd )

        {

        case 0:

            return iStartTime;

        case 1:

            return iSeparator;

        case 2:

            return iEndTime;

        default:

            return NULL;

        }

    }

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

// CTimeContainer::PositionChanged()

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

//

void CTimeContainer::PositionChanged()

    {

    FUNC_LOG;

    CCoeControl::PositionChanged();

    if( iStartTimeBgContext )

        {

        iStartTimeBgContext->SetFrameRects(

                iStartTime->Rect(),

                iStartTime->Rect() );

        }

    if( iEndTimeBgContext )

        {

        iEndTimeBgContext->SetFrameRects(

                iEndTime->Rect(),

                iEndTime->Rect() );

        }

    }

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

// CTimeContainer::SizeChanged

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

//

void CTimeContainer::SizeChanged()

    {

    FUNC_LOG;

    TInt x = CESMRLayoutManager::IsMirrored ( ) ? Rect().iBr.iX : Rect().iTl.iX;

    TPoint p( x, Rect().iTl.iY);

    TSize editorSize;

    TSize separatorSize;

    editorSize = iStartTime->MinimumSize();

    editorSize.iHeight = Rect().Height();

    separatorSize = iSeparator->MinimumSize();

    separatorSize.iHeight = Rect().Height();

    iStartTime->SetBorder( TGulBorder::ENone );

    iEndTime->SetBorder( TGulBorder::ENone );

    if ( CESMRLayoutManager::IsMirrored ( ) )

        {

        p.iX -= editorSize.iWidth;

        iStartTime->SetExtent ( p, editorSize );

        p.iX -= separatorSize.iWidth;

        iSeparator->SetExtent ( p, separatorSize );

        p.iX -= editorSize.iWidth;

        iEndTime->SetExtent ( p, editorSize );

        }

    else

        {

        iStartTime->SetExtent ( p, editorSize );

        p.iX += editorSize.iWidth;

        iSeparator->SetExtent ( p, separatorSize );

        p.iX += separatorSize.iWidth;

        iEndTime->SetExtent ( p, editorSize );

        }

    }

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

// CTimeContainer::OfferKeyEventL

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

//

TKeyResponse CTimeContainer::OfferKeyEventL(

        const TKeyEvent& aEvent,

        TEventCode aType )

    {

    FUNC_LOG;

    TBool startFocusedBefore( iStartTime->IsFocused() );

    TInt startIndex( iStartTime->CurrentField() );

    TBool endFocusedBefore( iEndTime->IsFocused() );

    TInt endIndex( iEndTime->CurrentField() );

    TKeyResponse response = EKeyWasNotConsumed;

    if ( aType == EEventKey )

        {

        switch ( aEvent.iScanCode )

            {

            case EStdKeyLeftArrow:

                response = ChangeFocusLeftL( aEvent, aType );

                break;

            case EStdKeyRightArrow:

                response = ChangeFocusRightL( aEvent, aType );

                break;

            default: // other events than left/right arrows

                {

                response = FocusedEditor()->OfferKeyEventL( aEvent, aType );

                }

                break;

            }

        }

    if ( EKeyWasConsumed == response )

        {

        CheckIfValidatingNeededL(

                startFocusedBefore,

                startIndex,

                endFocusedBefore,

                endIndex );

        }

    return response;

    }

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

// CTimeContainer::FocusChanged

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

//

void CTimeContainer::FocusChanged(

        TDrawNow /*aDrawNow*/)

    {

    FUNC_LOG;

    if ( IsFocused ( ) ) // if focus is gained

        {

        iStartTime->SetFocus ( ETrue );

        }

    else

        {

        if ( iStartTime->IsFocused() )

            {

            iStartTime->SetFocus( EFalse, EDrawNow );

            }

        if ( iEndTime->IsFocused() )

            {

            iEndTime->SetFocus( EFalse, EDrawNow );

            }

        }

    }

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

// CTimeContainer::SetFont

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

//

void CTimeContainer::SetFontL(

        const CFont* aFont,

        CESMRLayoutManager* aLayout )

    {

    FUNC_LOG;

    iLayout = aLayout;

    iStartTime->SetFont ( aFont );

    iSeparator->SetFont ( aFont );

    iEndTime->SetFont ( aFont );

    iStartTime->SetSkinTextColorL( aLayout->NormalTextColorID() );

    iEndTime->SetSkinTextColorL( aLayout->NormalTextColorID() );

    AknLayoutUtils::OverrideControlColorL ( *iSeparator, EColorLabelText,

                                             aLayout->NormalTextColor() );

    }

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

// CTimeContainer::FocusedEditor

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

//

CEikTimeEditor* CTimeContainer::FocusedEditor( )

    {

    FUNC_LOG;

    return iStartTime->IsFocused ( ) ? iStartTime : iEndTime;

    }

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

// CTimeContainer::OkToLoseFocusL

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

//

TBool CTimeContainer::OkToLoseFocusL(

        TESMREntryFieldId /*aFrom*/,

        TESMREntryFieldId /*aTo*/ )

    {

    FUNC_LOG;

    // validate the current time

    FocusedEditor()->PrepareForFocusLossL();

    if ( iStartTime->IsFocused() )

        {

        TriggerStartTimeChangedL();

        }

    else

        {

        TriggerEndTimeChangedL();

        }

    return ETrue;

    }

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

// CTimeContainer::ActivateL

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

//

void CTimeContainer::ActivateL()

    {

    FUNC_LOG;

    CCoeControl::ActivateL();

    TRect rect(TPoint(iStartTime->Position()), iStartTime->Size());

    TRect inner(rect);

    TRect outer(rect);

    delete iStartTimeBgContext;

    delete iEndTimeBgContext;

    iStartTimeBgContext = NULL;