/*

* 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 policy implementation

*

*/

#include "cesmrfield.h"

#include "esmrcommands.h"

#include "nmrlayoutmanager.h"

#include "mesmrfieldeventqueue.h"

#include "cesmrfieldcommandevent.h"

#include "cmrbackground.h"

#include "esmrcommands.h"

#include "emailtrace.h"

#include <txtrich.h>

#include <eikenv.h>

#include <baclipb.h>

#include <eikbtgpc.h>

#include <StringLoader.h>

#include <AknUtils.h>

#include <touchfeedback.h>

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

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

// CESMRField::CESMRField

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

//

EXPORT_C CESMRField::CESMRField()

    : iCustomMsk( EFalse ),

      iDisableRedraw( EFalse ),

      iDefaultMskVisible( EFalse ),

      iMskVisible( EFalse ),

      iLocked( EFalse )

    {

    FUNC_LOG;

    // do nothing

    }

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

// CESMRField::~CESMRField

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

//

EXPORT_C CESMRField::~CESMRField()

    {

    FUNC_LOG;

    delete iExtControl;

    if ( iEventQueue )

        {

        iEventQueue->RemoveObserver( this );

        }

    delete iBackground;

    }

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

// CESMRField::ConstructL

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

//

EXPORT_C void CESMRField::ConstructL(

        CCoeControl* aControl )

    {

    FUNC_LOG;

    iExtControl = aControl;

    iBackground = CMRBackground::NewL();

    this->SetBackground( iBackground );

    }

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

// CESMRField::InitializeL

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

//

EXPORT_C void CESMRField::InitializeL()

    {

    FUNC_LOG;

    /* Empty implementation, subclasses should overwrite */

    }

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

// CESMRField::FontChangedL

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

//

EXPORT_C void CESMRField::FontChangedL()

    {

    FUNC_LOG;

    // This method re-initializes field

    InitializeL();

    }

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

// CESMRField::SetFieldId

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

//

EXPORT_C void CESMRField::SetFieldId( TESMREntryFieldId aFieldId )

    {

    FUNC_LOG;

    iFieldId = aFieldId;

    }

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

// CESMRField::SetPreItemIndex

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

//

EXPORT_C void CESMRField::SetPreItemIndex( TInt aPreItemIndex )

    {

    FUNC_LOG;

    iPreItemIndex = aPreItemIndex;

    }

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

// CESMRField::SetCurrentItemIndex

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

//

EXPORT_C void CESMRField::SetCurrentItemIndex( TInt aCurrentItemIndex )

    {

    FUNC_LOG;

    iCurrentItemIndex = aCurrentItemIndex;

    }

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

// CESMRField::FieldId

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

//

EXPORT_C TESMREntryFieldId CESMRField::FieldId() const

    {

    FUNC_LOG;

    return iFieldId;

    }

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

// CESMRField::PreItemIndex

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

//

EXPORT_C TInt CESMRField::PreItemIndex() const

    {

    FUNC_LOG;

    return iPreItemIndex;

    }

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

// CESMRField::CurrentItemIndex

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

//

EXPORT_C TInt CESMRField::CurrentItemIndex() const

    {

    FUNC_LOG;

    return iCurrentItemIndex;

    }

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

// CESMRField::SizeChanged

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

//

EXPORT_C void CESMRField::SizeChanged()

    {

    FUNC_LOG;

    TRect rect( Rect() );

    if ( iExtControl )

        {

        iExtControl->SetRect( rect );

        }

    }

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

// CESMRField::CountComponentControls

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

//

EXPORT_C TInt CESMRField::CountComponentControls() const

    {

    FUNC_LOG;

    TInt count( 0 );

    if ( iExtControl )

    	{

        ++count;

    	}

    return count;

    }

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

// CESMRField::ComponentControl

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

//

EXPORT_C CCoeControl* CESMRField::ComponentControl( TInt /*aInd*/ ) const

    {

    FUNC_LOG;

    return iExtControl;

    }

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

// CESMRField::MinimumSize

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

//

EXPORT_C TSize CESMRField::MinimumSize()

    {

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

    TAknLayoutRect listareaLayoutRect =

        NMRLayoutManager::GetLayoutRect( parentRect, NMRLayoutManager::EMRLayoutListArea );

    TAknLayoutRect fieldLayoutRect =

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

    return TSize( Parent()->Size().iWidth, fieldLayoutRect.Rect().Height() );

    }

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

// CESMRField::HandlePointerEventL

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

//

EXPORT_C void CESMRField::HandlePointerEventL(

        const TPointerEvent& aPointerEvent )

    {

    FUNC_LOG;

    // Sanity check that pointer event occurs in field area

    if ( Rect().Contains( aPointerEvent.iPosition ) )

        {

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

            {

            if ( !HandleSingletapEventL( aPointerEvent.iPosition ) )

                {

                // Provide raw pointer event to field

                HandleRawPointerEventL( aPointerEvent );

                }

            }

        else // Provide other pointer events to fields

            {

            if ( !HandleRawPointerEventL( aPointerEvent ) )

                {

                // Provide pointer events to child components if field

                // did not already consume the event

                CCoeControl::HandlePointerEventL( aPointerEvent );

                }

            }

        }

    }

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

// CESMRField::SetContainerWindowL

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

//

EXPORT_C void CESMRField::SetContainerWindowL(const CCoeControl& aContainer)

    {

    FUNC_LOG;

    CCoeControl::SetContainerWindowL( aContainer );

        {

        }

    }

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

// CESMRField::SetListObserver

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

//

EXPORT_C void CESMRField::SetListObserver( MESMRListObserver* aObserver )

    {

    FUNC_LOG;

    iObserver = aObserver;

    ListObserverSet();

    }

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

// CESMRField::ListObserverSet

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

//

EXPORT_C void CESMRField::ListObserverSet()

    {

    FUNC_LOG;

    // default implementation.

    }

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

// CESMRField::OfferKeyEventL

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

//

EXPORT_C TKeyResponse CESMRField::OfferKeyEventL(

		const TKeyEvent& aEvent, TEventCode aType )

    {

    FUNC_LOG;

    TKeyResponse response( EKeyWasNotConsumed );

    if ( iExtControl )

        {

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

        }

    // If key event was not consumed, and it is the Enter,

    // let's execute generic command Open

    if ( response == EKeyWasNotConsumed

         && aType == EEventKey

         && ( aEvent.iCode == EKeyEnter

              || aEvent.iScanCode == EStdKeyEnter ) )

        {

        ExecuteGenericCommandL( EAknCmdOpen );

        }

    return response;

    }

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

// CESMRField::SetOutlineFocusL

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

//

EXPORT_C void CESMRField::SetOutlineFocusL( TBool aFocus )

    {

    FUNC_LOG;

    iOutlineFocus = aFocus;

    if ( iExtControl )

        {

        iExtControl->SetFocus( aFocus );

        }

    if ( aFocus )

        {

        CEikButtonGroupContainer* cba = CEikButtonGroupContainer::Current();

        if ( cba )

            {

            iDefaultMskVisible = cba->IsCommandVisibleByPosition(

                    CEikButtonGroupContainer::EMiddleSoftkeyPosition );

            iMskVisible = iDefaultMskVisible;

            }

        }

    else

        {

        RestoreMiddleSoftKeyL();

        }

    }

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

// CESMRField::OkToLoseFocusL

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

//

EXPORT_C TBool CESMRField::OkToLoseFocusL( // codescanner::LFunctionCantLeave

        TESMREntryFieldId /*aNextItem*/ )

    {

    FUNC_LOG;

    return ETrue;

    }

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

// CESMRField::GetMinimumVisibleVerticalArea

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

//

EXPORT_C void CESMRField::GetMinimumVisibleVerticalArea(

		TInt& aUpper, TInt& aLower)

    {

    FUNC_LOG;

    aUpper = 0;

    aLower = Rect().iBr.iY - Rect().iTl.iY;

    }

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

// CESMRField::GetCursorLineVerticalPos

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

//

EXPORT_C void CESMRField::GetCursorLineVerticalPos(TInt& aUpper, TInt& aLower)

    {

    FUNC_LOG;

    aUpper = 0;

    aLower = Rect().iBr.iY - Rect().iTl.iY;

    }

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

// CESMRField::InternalizeL

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

//

EXPORT_C void CESMRField::InternalizeL( // codescanner::LFunctionCantLeave

        MESMRCalEntry& /*aEntry*/ )

    {

    FUNC_LOG;

    /* Empty implementation, subclasses should overwrite */

    }

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

// CESMRField::ExternalizeL

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

//

EXPORT_C void CESMRField::ExternalizeL( // codescanner::LFunctionCantLeave

        MESMRCalEntry& /*aEntry*/ )

    {

    FUNC_LOG;

    /* Empty implementation, subclasses should overwrite */

    }

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

// CESMRField::ExecuteGenericCommandL

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

//

EXPORT_C TBool CESMRField::ExecuteGenericCommandL( TInt /*aCommand*/ )

    {

    FUNC_LOG;

    return EFalse;

    /* Subclasses should overwrite */

    }

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

// CESMRField::LongtapDetectedL

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

//

EXPORT_C void CESMRField::LongtapDetectedL( const TPoint& aPosition )

    {

    FUNC_LOG;

    HandleLongtapEventL( aPosition );

    }

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

// CESMRField::SetTitlePaneObserver

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

//

EXPORT_C void CESMRField::SetTitlePaneObserver(

		MESMRTitlePaneObserver* /*aObserver*/ )

    {

    FUNC_LOG;

    /* Empty implementation, subclasses should overwrite */

    }

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

// CESMRField::ChangeMiddleSoftKeyL

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

//

EXPORT_C void CESMRField::ChangeMiddleSoftKeyL(

        TInt aCommandId,

        TInt aResourceId )

    {

    FUNC_LOG;

    if ( AknLayoutUtils::MSKEnabled() )

        {

        CEikButtonGroupContainer* cba = CEikButtonGroupContainer::Current();

        if ( cba )

            {

            HBufC* middleSKText = StringLoader::LoadLC( aResourceId,

                                                        iCoeEnv );

            cba->SetCommandL(

                    CEikButtonGroupContainer::EMiddleSoftkeyPosition,

                    aCommandId, *middleSKText );

            CleanupStack::PopAndDestroy( middleSKText );

            if ( !iMskVisible )

                {

                cba->MakeCommandVisibleByPosition(

                        CEikButtonGroupContainer::EMiddleSoftkeyPosition,

                        ETrue );

                iMskVisible = ETrue;

                }

            cba->DrawDeferred();

            iCustomMsk = ETrue;

            }

        }

    }

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

// CESMRField::SetValidatorL

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

//

EXPORT_C void CESMRField::SetValidatorL( MESMRFieldValidator* aValidator )

    {