/*

* Copyright (c) 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 repeat until field implementation

 *

*/

#include "cesmrrepeatuntil.h"

#include "mesmrfieldvalidator.h"

#include "cesmrglobalnote.h"

#include "esmrfieldbuilderdef.h"

#include "nmrlayoutmanager.h"

#include "nmrcolormanager.h"

#include "cmrlabel.h"

#include "nmrbitmapmanager.h"

#include <eikmfne.h>

#include <StringLoader.h>

#include <esmrgui.rsg>

#include <AknsBasicBackgroundControlContext.h>

#include "emailtrace.h"

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

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

// CESMRRepeatUntilField::CESMRRepeatUntilField

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

//

CESMRRepeatUntilField::CESMRRepeatUntilField( 

        MESMRFieldValidator* aValidator )

    {

    FUNC_LOG;

    iValidator = aValidator;

    SetFieldId( EESMRFieldRecurrenceDate );

    SetFocusType( EESMRHighlightFocus );

    }

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

// CESMRRepeatUntilField::~CESMRRepeatUntilField

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

//

CESMRRepeatUntilField::~CESMRRepeatUntilField( )

    {

    FUNC_LOG;

    delete iLabel;

    delete iBgCtrlContext;

    }

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

// CESMRRepeatUntilField::NewL

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

//

CESMRRepeatUntilField* CESMRRepeatUntilField::NewL(

        MESMRFieldValidator* aValidator )

    {

    FUNC_LOG;

    CESMRRepeatUntilField* self =

            new( ELeave )CESMRRepeatUntilField( aValidator );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CESMRRepeatUntilField::ConstructL

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

//

void CESMRRepeatUntilField::ConstructL( )

    {

    FUNC_LOG;

    SetComponentsToInheritVisibility( ETrue );

    HBufC* label = StringLoader::LoadLC( R_QTN_MEET_REQ_REPEAT_UNTIL );

    iLabel = CMRLabel::NewL();

    iLabel->SetParent( this );

    iLabel->SetTextL( *label );

    CleanupStack::PopAndDestroy( label );

    TTime startTime;

    startTime.UniversalTime();

    iDate = new( ELeave )CEikDateEditor;

    CESMRField::ConstructL( iDate ); //ownership transferred

    iDate->ConstructL(

            KAknMinimumDate,

            TTIME_MAXIMUMDATE,

            startTime,

            EFalse );

    iDate->SetUpAndDownKeysConsumed ( EFalse );

    if ( iValidator )

        {

        iValidator->SetRecurrenceUntilDateFieldL( *iDate );

        }

    TRect tempRect( 0, 0, 0, 0 );

    // Setting background instead of theme skin  

    NMRBitmapManager::TMRBitmapStruct bitmapStruct;

    bitmapStruct = NMRBitmapManager::GetBitmapStruct( NMRBitmapManager::EMRBitmapInputCenter );

    iBgCtrlContext = CAknsBasicBackgroundControlContext::NewL( 

                bitmapStruct.iItemId, 

                tempRect, 

                EFalse );

    iDate->SetSkinBackgroundControlContextL( iBgCtrlContext );

    }

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

// CESMRRepeatUntilField::MinimumSize

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

//

TSize CESMRRepeatUntilField::MinimumSize()

    {

    TRect parentRect( Parent()->Rect() );

    TRect richTextRect = 

            NMRLayoutManager::GetFieldLayoutRect( parentRect, 1 ).Rect();

    // Add title area to the required size

    TSize titleSize( CESMRField::MinimumSize() );

    TSize completeFieldSize( titleSize );

    completeFieldSize.iHeight += richTextRect.Height();

    return completeFieldSize;

    }

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

// CESMRRepeatUntilField::OkToLoseFocusL

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

//

TBool CESMRRepeatUntilField::OkToLoseFocusL( TESMREntryFieldId /*aNextItem*/ )

    {

    FUNC_LOG;

    TRAPD(err, iValidator->RecurrenceEndDateChangedL() );

    if ( KErrNone != err )

        {

        CESMRGlobalNote::ExecuteL(

                CESMRGlobalNote::EESMRRepeatEndEarlierThanItStart );

        }

    return( KErrNone == err );

    }

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

// CESMRRepeatUntilField::CountComponentControls

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

//

TInt CESMRRepeatUntilField::CountComponentControls( ) const

    {

    FUNC_LOG;

    TInt count( 0 );

    if( iLabel )

        {

        ++count;

        }

    if( iDate )

        {

        ++count;

        }

    return count;

    }

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

// CESMRRepeatUntilField::ComponentControl

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

//

CCoeControl* CESMRRepeatUntilField::ComponentControl( TInt aInd ) const

    {

    FUNC_LOG;

    switch ( aInd )

        {

        case 0:

            return iLabel;

        case 1:

            return iDate;

        default:

            return NULL;

        }

    }

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

// CESMRRepeatUntilField::SizeChanged

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

//

void CESMRRepeatUntilField::SizeChanged()

    {

    FUNC_LOG;

    TRect rect( Rect() );

    // Layouting label

    TAknLayoutRect rowLayoutRect =

        NMRLayoutManager::GetFieldRowLayoutRect( rect, 1 );

    TRect rowRect = rowLayoutRect.Rect();

    // Layout label to first row's rect

    TAknTextComponentLayout titleLayout =

        NMRLayoutManager::GetTextComponentLayout( 

                NMRLayoutManager::EMRTextLayoutText );

    AknLayoutUtils::LayoutLabel( iLabel, rect, titleLayout );

    // Move upper left corner below first line and get second row's rect.

    rect.iTl.iY += rowRect.Height();

    rowLayoutRect =

        NMRLayoutManager::GetFieldRowLayoutRect( rect, 2 );

    rowRect = rowLayoutRect.Rect();

    // Layouting date editor

    if( iDate )

        {

        TAknLayoutRect bgLayoutRect = 

            NMRLayoutManager::GetLayoutRect( 

                    rowRect, NMRLayoutManager::EMRLayoutTextEditorBg );

        TRect bgRect( bgLayoutRect.Rect() );

        // Move focus rect so that it's relative to field's position.

        bgRect.Move( -Position() );

        SetFocusRect( bgRect );

        TAknTextComponentLayout editorLayout =

            NMRLayoutManager::GetTextComponentLayout( 

                    NMRLayoutManager::EMRTextLayoutDateEditor );

        AknLayoutUtils::LayoutMfne( iDate, rect, editorLayout );

        NMRColorManager::SetColor( *iDate, 

                                   NMRColorManager::EMRMainAreaTextColor );

        }

    }

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

// CESMRRepeatUntilField::OfferKeyEventL

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

//

TKeyResponse CESMRRepeatUntilField::OfferKeyEventL(

        const TKeyEvent& aEvent,

        TEventCode aType )

    {

    FUNC_LOG;

    TKeyResponse response( EKeyWasNotConsumed);

    if ( aType == EEventKey )

        {

        TInt fieldIndex( iDate->CurrentField() );

        response = CESMRField::OfferKeyEventL( aEvent, aType );

        if ( aEvent.iScanCode != EStdKeyUpArrow &&

             aEvent.iScanCode != EStdKeyDownArrow )

        	{

            iDate->DrawDeferred();

        	}

        }

    return response;

    }

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

// CESMRRepeatUntilField::CheckIfValidatingNeededL

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

//

void CESMRRepeatUntilField::CheckIfValidatingNeededL(

        TInt aStartFieldIndex )

    {

    FUNC_LOG;

    TInt fieldIndex( iDate->CurrentField() );

    if ( fieldIndex != aStartFieldIndex && iValidator )

        {

        TRAPD(err, iValidator->RecurrenceEndDateChangedL() );

        if ( KErrNone != err )

            {

            CESMRGlobalNote::ExecuteL(

                    CESMRGlobalNote::EESMRRepeatEndEarlierThanItStart );

            }

        }

    }

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

// CESMRRepeatUntilField::SetOutlineFocusL

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

//

void CESMRRepeatUntilField::SetOutlineFocusL( TBool aFocus )

    {

    FUNC_LOG;

    CESMRField::SetOutlineFocusL ( aFocus );

    if ( aFocus )

        {

        ChangeMiddleSoftKeyL(EESMRCmdSaveMR,R_QTN_MSK_SAVE);

        }

    }

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

// CESMRRepeatUntilField::SetValidatorL

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

//

void CESMRRepeatUntilField::SetValidatorL( MESMRFieldValidator* aValidator )

    {

    FUNC_LOG;

    CESMRField::SetValidatorL( aValidator );

    if ( iValidator )

        {

        iValidator->SetRecurrenceUntilDateFieldL( *iDate );

        }

    }

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

// CESMRRepeatUntilField::ExecuteGenericCommandL()

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

//

TBool CESMRRepeatUntilField::ExecuteGenericCommandL( TInt aCommand )

    {

    FUNC_LOG;

    TBool retValue( EFalse );

    if ( EMRCmdDoEnvironmentChange == aCommand )

        {

        // Locale has been changed       

        DoEnvChangeL();

        retValue = ETrue;

        }

    return retValue;

    }

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

// CESMRRepeatUntilField::SetContainerWindowL

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

//

void CESMRRepeatUntilField::SetContainerWindowL( 

        const CCoeControl& aContainer )

    {

    iContainerWindow = &aContainer;

    CCoeControl::SetContainerWindowL( aContainer );

    iDate->SetContainerWindowL( aContainer );

    iLabel->SetContainerWindowL( aContainer );

    iDate->SetParent( this );

    iLabel->SetParent( this );

    }

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

// CESMRRepeatUntilField::DoEnvChangeL

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

//

void CESMRRepeatUntilField::DoEnvChangeL()

    {

    FUNC_LOG;

    CEikDateEditor* date = new( ELeave )CEikDateEditor;

    CleanupStack::PushL( date );

    date->ConstructL( 

            TTIME_MINIMUMDATE, 

            TTIME_MAXIMUMDATE, 

            iDate->Date(), 

            EFalse );

    date->SetUpAndDownKeysConsumed( EFalse );        

    UpdateExtControlL( date );

    CleanupStack::Pop( date );

    iDate = date;

    if ( iValidator )

        {

        iValidator->SetRecurrenceUntilDateFieldL( *iDate );

        }    

    iDate->SetSkinBackgroundControlContextL( iBgCtrlContext );        

    SetContainerWindowL( *iContainerWindow );

    iDate->ActivateL();        

    SizeChanged();

    DrawDeferred();      

    }

// EOF