/*

* 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 location field implementation

 *  Version     : %version: tr1sido#10 %

 *

 */

#include "emailtrace.h"

#include "cesmrlocationfield.h"

// SYSTEM INCLUDES

#include <calentry.h>

#include <StringLoader.h>

#include <AknUtils.h>

#include <AknsUtils.h>

#include <AknIconUtils.h>

#include <esmrgui.rsg>

#include <AknsDrawUtils.h>

#include <AknsFrameBackgroundControlContext.h>

#include <data_caging_path_literals.hrh>

// INCLUDES

#include "esmrfieldbuilderdef.h"

#include "cesmreditor.h"

#include "cesmrfeaturesettings.h"

#include "esmrhelper.h"

#include "cesmrborderlayer.h"

#include "mesmrfieldevent.h"

#include "cesmrgenericfieldevent.h"

#include "cesmrlayoutmgr.h"

#include "cesmrglobalnote.h"

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

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

// CESMRLocationField::NewL

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

//

CESMRLocationField* CESMRLocationField::NewL( )

    {

    FUNC_LOG;

    CESMRLocationField* self = new (ELeave) CESMRLocationField;

    CleanupStack::PushL ( self );

    self->ConstructL ( );

    CleanupStack::Pop ( self );

    return self;

    }

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

// CESMRLocationField::~CESMRLocationField

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

//

CESMRLocationField::~CESMRLocationField( )

    {

    FUNC_LOG;

    delete iIcon;

    delete iWaypointIcon;

    delete iWaypointIconMask;

    delete iFrameBgContext;

    delete iFeatures;

    delete iLocationText;

    }

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

// CESMRLocationField::InitializeL

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

//

void CESMRLocationField::InitializeL()

    {

    FUNC_LOG;

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

    AknLayoutUtils::OverrideControlColorL( *iLocation, 

                                            EColorControlBackground,

                                            iLayout->NormalTextBgColor() );

    }

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

// CESMRLocationField::InternalizeL

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

//

void CESMRLocationField::InternalizeL( MESMRCalEntry& aEntry )

    {

    FUNC_LOG;

    CCalEntry& entry = aEntry.Entry();

    HBufC* location = entry.LocationL().AllocLC();

    // if there is no text available, don't overwrite the default text

    // with empty descriptor.

    if ( location->Length() > 0 )

        {

        iLocation->ClearSelectionAndSetTextL( *location );

        }

    CleanupStack::PopAndDestroy( location );

    // this is needed to be re-called here, otherwise the CEikEdwin

    // does not get correctly instantiated with default text

    iLocation->FocusChanged( EDrawNow );

    }

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

// CESMRLocationField::ExternalizeL

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

//

void CESMRLocationField::ExternalizeL( MESMRCalEntry& aEntry )

    {

    FUNC_LOG;

    HBufC* loc = iLocation->GetTextInHBufL( );

    if ( loc )

        {

        CleanupStack::PushL( loc );

        // externalize the text only if it differs from the

        // default text. In other words, default text is not

        // externalized.

        HBufC* defaultText = StringLoader::LoadLC( R_QTN_MEET_REQ_LOCATION_FIELD );

        if ( defaultText->Compare( *loc ) != 0 )

            {

            CCalEntry& entry = aEntry.Entry();

            entry.SetLocationL( *loc );

            }

        CleanupStack::PopAndDestroy( defaultText );

        CleanupStack::PopAndDestroy( loc );

        }

    else

        {

        CCalEntry& entry = aEntry.Entry();

        entry.SetLocationL( KNullDesC );

        }

    }

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

// CESMRLocationField::SetOutlineFocusL

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

//

void CESMRLocationField::SetOutlineFocusL( TBool aFocus )

    {

    FUNC_LOG;

    CESMRField::SetOutlineFocusL ( aFocus );

    if ( FeaturesL().FeatureSupported(

            CESMRFeatureSettings::EESMRUILocationFeatures ) )

        {

        if ( aFocus )

            {

            ChangeMiddleSoftKeyL( EAknSoftkeyContextOptions, R_QTN_MSK_OPEN );

            }

        else

            {

            if ( iLocationText )

                {

                delete iLocationText;

                iLocationText = NULL;

                }

            iLocationText = iLocation->GetTextInHBufL();

            HBufC* defaultText = StringLoader::LoadLC( R_QTN_MEET_REQ_LOCATION_FIELD );

            if ( iLocationText && iLocationText->Compare( *defaultText ) != 0 )

                {

                // Create field change event

                CESMRGenericFieldEvent* event = CESMRGenericFieldEvent::NewLC(

                        this,

                        MESMRFieldEvent::EESMRFieldChangeEvent );

                // Add this field as parameter

                TInt fieldId = iFieldId;

                CESMRFieldEventValue* field = CESMRFieldEventValue::NewLC(

                        MESMRFieldEventValue::EESMRInteger,

                        &fieldId );

                event->AddParamL( field );

                CleanupStack::Pop( field );

                // Add new value as parameter

                CESMRFieldEventValue* value = CESMRFieldEventValue::NewLC(

                        CESMRFieldEventValue::EESMRString,

                        iLocationText );

                iLocationText = NULL; // Ownership transferred to value

                // Encapsulate value, so receiver gets the field value type

                event->AddParamL( value, ETrue );

                CleanupStack::Pop( value );

                // Send event

                NotifyEventAsyncL( event );

                CleanupStack::Pop( event );

                }

            CleanupStack::PopAndDestroy( defaultText );

            }

        }

    }

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

// CESMRLocationField::ExpandedHeight

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

//

TInt CESMRLocationField::ExpandedHeight( ) const

    {

    FUNC_LOG;

    return iSize.iHeight;

    }

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

// CESMRLocationField::HandleEdwinSizeEventL

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

//

TBool CESMRLocationField::HandleEdwinSizeEventL( CEikEdwin* aEdwin,

        TEdwinSizeEvent /*aType*/, TSize aSize )

    {

    FUNC_LOG;

    TBool ret( EFalse );

    TSize newSize = CalculateEditorSize( aSize );

    if ( aEdwin == iLocation && iSize != newSize )

            {

        iSize = newSize;

            if ( iObserver && aEdwin->IsFocused() )

            {

            iObserver->ControlSizeChanged (this );

            }

        if ( iFrameBgContext )

            {

            TRect visibleRect = CalculateVisibleRect( iLocation->Rect() );

            iFrameBgContext->SetFrameRects( visibleRect, visibleRect );

            }

        ret = ETrue;

        }

    return ret;

    }

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

// CESMRLocationField::HandleEdwinEventL

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

//

void CESMRLocationField::HandleEdwinEventL(CEikEdwin* aEdwin, TEdwinEvent aEventType)

	{

    FUNC_LOG;

    if ( aEdwin == iLocation && aEventType == EEventTextUpdate )

        {

        HBufC* text = iLocation->GetTextInHBufL();

        if ( text )

            {

            CleanupStack::PushL( text );

            TInt textLength( text->Length() );

            if ( iLocation->GetLimitLength() <= textLength )

            	{

            	NotifyEventAsyncL( EESMRCmdSizeExceeded );

            	}            

            CleanupStack::PopAndDestroy( text );

            }

        }	

	}

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

// CESMRLocationField::CESMRLocationField

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

//

CESMRLocationField::CESMRLocationField()

    : iSize( TSize( 0, 0 ) )

    {

    FUNC_LOG;

    //do nothing

    }

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

// CESMRLocationField::ActivateL

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

//

void CESMRLocationField::ActivateL()

    {

    FUNC_LOG;

    CCoeControl::ActivateL();

    TRect rect( iLocation->Rect() );

    TRect inner(rect);

    TRect outer(rect);

    delete iFrameBgContext;

    iFrameBgContext = NULL;

    iFrameBgContext = CAknsFrameBackgroundControlContext::NewL( 

            KAknsIIDQsnFrInput, 

            outer, 

            inner, 

            EFalse ) ;

    iFrameBgContext->SetParentContext( iBackground );

    iLocation->SetSkinBackgroundControlContextL( iFrameBgContext );

    }

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

// CESMRLocationField::PositionChanged()

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

//

void CESMRLocationField::PositionChanged()

    {

    FUNC_LOG;

    CCoeControl::PositionChanged();

    if ( iFrameBgContext )

        {

        TRect visibleRect = CalculateVisibleRect( iLocation->Rect() );

        iFrameBgContext->SetFrameRects( visibleRect, visibleRect );

        }

    }

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

// CESMRLocationField::ConstructL

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

//

void CESMRLocationField::ConstructL()

    {

    FUNC_LOG;

    SetFieldId( EESMRFieldLocation );

    SetExpandable();

    iLocation = CESMREditor::NewL( this, 

                                   1,

                                   KMaxTextLength, //from ICAL spec.

                                   // do not change. other text fields do not

                                   // have this limitation

                                   CEikEdwin::EResizable |

                                   CEikEdwin::EAvkonEditor );

    iLocation->SetEdwinSizeObserver( this );

    iLocation->SetEdwinObserver( this );

    HBufC* buf = StringLoader::LoadLC( R_QTN_MEET_REQ_LOCATION_FIELD );

    iLocation->SetDefaultTextL( buf ); // ownership is transferred

    CleanupStack::Pop( buf );

    CESMRIconField::ConstructL( KAknsIIDQgnMeetReqIndiLocation, iLocation );

    }

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

// CESMRLocationField::GetMinimumVisibleVerticalArea

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

//

void CESMRLocationField::GetMinimumVisibleVerticalArea(TInt& aUpper, TInt& aLower)

    {

    FUNC_LOG;

    aLower = iLocation->CurrentLineNumber() * iLocation->RowHeight();

    aUpper = aLower - iLocation->RowHeight();

    }

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

// CESMRLocationField::ListObserverSet

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

//

void CESMRLocationField::ListObserverSet()

    {

    FUNC_LOG;

    iLocation->SetListObserver( iObserver );

    }

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

// CESMRLocationField::ListObserverSet

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

//

CESMRFeatureSettings& CESMRLocationField::FeaturesL()

    {

    FUNC_LOG;

    if ( !iFeatures )

        {

        iFeatures = CESMRFeatureSettings::NewL();

        }

    return *iFeatures;

    }

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

// CESMRCheckbox::SetWaypointIconL

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

//

void CESMRLocationField::SetWaypointIconL( TBool aEnabled )

    {

    FUNC_LOG;

    delete iIcon;

    iIcon = NULL;

    delete iWaypointIcon;

    iWaypointIcon = NULL;

    delete iWaypointIconMask;

    iWaypointIconMask = NULL;

    if( aEnabled )

        {

        TAknsItemID iconID;

        TInt fileIndex(-1);

        TInt fileMaskIndex(-1);

        iconID = KAknsIIDQgnPropBlidWaypoint;

        CESMRLayoutManager::SetBitmapFallback( iconID,

                                               fileIndex,

                                               fileMaskIndex );

        TFileName bitmapFilePath;

        ESMRHelper::LocateResourceFile(

                KESMRMifFile,

                KDC_APP_BITMAP_DIR,

                bitmapFilePath);

        AknsUtils::CreateIconL( AknsUtils::SkinInstance(),

                                iconID,

                                iWaypointIcon,

                                iWaypointIconMask,

                                bitmapFilePath,

                                fileIndex,

                                fileMaskIndex

                                );

        // Even if creating mask failed, bitmap can be used (background is just not displayed correctly)

        if( iWaypointIcon )

            {

            AknIconUtils::SetSize( iWaypointIcon, KIconSize, EAspectRatioPreserved );

            iIcon = new (ELeave) CEikImage;

            iIcon->SetPictureOwnedExternally(ETrue);

            iIcon->SetPicture( iWaypointIcon, iWaypointIconMask );

            LayoutWaypointIcon();

            // change text rect size to fit icon

            iBorder->SetSize( BorderSize() );

            }

        }

    }

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

// CESMRLocationField::CountComponentControls

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

//

TInt CESMRLocationField::CountComponentControls( ) const

    {

    FUNC_LOG;

    TInt count = CESMRIconField::CountComponentControls ( );

    if ( iIcon )

        {

        ++count;

        }

    return count;

    }

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

// CESMRLocationField::ComponentControl

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

//

CCoeControl* CESMRLocationField::ComponentControl( TInt aInd ) const

    {

    FUNC_LOG;

    if ( aInd == 2 )

        {

        return iIcon;

        }

    return CESMRIconField::ComponentControl ( aInd );

    }

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

// CESMRLocationField::SizeChanged

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

//

void CESMRLocationField::SizeChanged( )

    {

    FUNC_LOG;

    CESMRIconField::SizeChanged();

    PositionFieldElements(); 

    }

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

// CESMRLocationField::PositionFieldElements

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

//

void CESMRLocationField::PositionFieldElements()

    {

    FUNC_LOG;

    // editor (editor is wrapped inside the 'iBorder' member)

    if ( iIcon )

        {

        LayoutWaypointIcon();

        if ( iFrameBgContext && iBorder )

            {

            TRect visibleRect = CalculateVisibleRect( iLocation->Rect() );

            iFrameBgContext->SetFrameRects( visibleRect, visibleRect );

            }

        }

    }

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

// CESMRLocationField::HandleFieldEventL

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

//

void CESMRLocationField::HandleFieldEventL( const MESMRFieldEvent& aEvent )

    {

    FUNC_LOG;

    if ( aEvent.Type() == MESMRFieldEvent::EESMRFieldCommandEvent )

        {

        TInt* command = static_cast< TInt* >( aEvent.Param( 0 ) );

        switch ( *command )

            {

            case EESMRCmdDisableWaypointIcon:

                {

                SetWaypointIconL( EFalse );

                break;

                }

            case EESMRCmdEnableWaypointIcon:

                {

                SetWaypointIconL( ETrue );

                break;

                }

            default:

                {

                break;

                }

            }