/*

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

 *  Version     : %version: e002sa32#53.1.3 %

 *

 */

#include "cesmrlocationfield.h"

#include "esmrfieldbuilderdef.h"

#include "cesmreditor.h"

#include "cesmrfeaturesettings.h"

#include "esmrhelper.h"

#include "mesmrfieldevent.h"

#include "cesmrgenericfieldevent.h"

#include "cesmrglobalnote.h"

#include "cmrbutton.h"

#include "cmrlabel.h"

#include "cmrimage.h"

#include "nmrlayoutmanager.h"

#include "nmrbitmapmanager.h"

#include "cmrstyluspopupmenu.h"

#include "mesmrlistobserver.h"

#include <calentry.h>

#include <StringLoader.h>

#include <esmrgui.rsg>

#include <data_caging_path_literals.hrh>

#include <AknsBasicBackgroundControlContext.h>

#include <eikmfne.h>

#include <aknbutton.h>

#include "emailtrace.h"

#include "esmrconfig.hrh"

// ======== 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;

    SetFieldId( EESMRFieldLocation );

    SetFocusType( EESMRHighlightFocus );

    }

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

// CESMRLocationField::ConstructL

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

//

void CESMRLocationField::ConstructL()

    {

    FUNC_LOG;

    iFieldButton = CMRButton::NewL( NMRBitmapManager::EMRBitmapLocation );

    iFieldButton->SetParent( this );

    iTitle = CMRLabel::NewL();

    iTitle->SetParent( this );

    HBufC* title = StringLoader::LoadLC(

            R_MEET_REQ_OPTIONS_ADD_LOCATION,

            iCoeEnv );

    iTitle->SetTextL( *title );

    CleanupStack::PopAndDestroy( title );

    iLocation = CESMREditor::NewL( this,

                                   1,

                                   KMaxTextLength, //from ICAL spec.

                                   // do not change. other text fields do not

                                   // have this limitation

                                   CEikEdwin::EResizable |

                                   CEikEdwin::EAvkonEditor );

    CESMRField::ConstructL( iLocation ); //ownership transfered

    iLocation->SetEdwinSizeObserver( this );

    iLocation->SetEdwinObserver( this );

    iLocation->SetParent( this );

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

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

    CleanupStack::Pop( buf );

    // Setting background instead of theme skin

    NMRBitmapManager::TMRBitmapStruct bitmapStruct;

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

    TRect initialisationRect( 0, 0, 0, 0 );

    iBgControlContext = CAknsBasicBackgroundControlContext::NewL(

                bitmapStruct.iItemId,

                initialisationRect,

                EFalse );

    iLocation->SetSkinBackgroundControlContextL( iBgControlContext );

    }

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

// CESMRLocationField::~CESMRLocationField

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

//

CESMRLocationField::~CESMRLocationField()

    {

    FUNC_LOG;

    delete iFieldButton;

    delete iWaypointIcon;

    delete iFeatures;

    delete iLocationText;

    delete iBgControlContext;

    delete iMenu;

    delete iTitle;

    }

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

// CESMRLocationField::MinimumSize

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

//

TSize CESMRLocationField::MinimumSize()

    {

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

    TRect richTextRect =

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

    TRect textRect( NMRLayoutManager::GetLayoutText(

            richTextRect,

       NMRLayoutManager::EMRTextLayoutTextEditor ).TextRect() );

    // Adjust field size so that there's room for expandable editor.

    richTextRect.Resize( 0, iSize.iHeight - textRect.Height() );

    // Add title area to the required size

    TSize titleSize( CESMRField::MinimumSize() );

    TSize completeFieldSize( titleSize );

    completeFieldSize.iHeight += richTextRect.Height();

    return completeFieldSize;

    }

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

// CESMRLocationField::InitializeL

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

//

void CESMRLocationField::InitializeL()

    {

    FUNC_LOG;

    // Do nothing

    }

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

// 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 );

    // If the geo value has been set, the waypoint icon has to be shown on right

    // side of the location field

    CCalGeoValue* geoValue = aEntry.Entry().GeoValueL();

    TReal dummy;

    SetWaypointIconL( geoValue && geoValue->GetLatLong( dummy, dummy ) );

    // 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,

                iCoeEnv );

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

            {

            CCalEntry& entry = aEntry.Entry();

            entry.SetLocationL( *loc );

            }

        else if ( !iWaypointIcon )

            {

            aEntry.Entry().ClearGeoValueL();

            }

        CleanupStack::PopAndDestroy( defaultText );

        CleanupStack::PopAndDestroy( loc );

        }

    else

        {

        CCalEntry& entry = aEntry.Entry();

        entry.SetLocationL( KNullDesC );

        entry.ClearGeoValueL();

        }

    }

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

// 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,

                    iCoeEnv );

            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::HandleEdwinSizeEventL

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

//

TBool CESMRLocationField::HandleEdwinSizeEventL( CEikEdwin* aEdwin,

        TEdwinSizeEvent /*aType*/, TSize aSize )

    {

    FUNC_LOG;

    TBool reDraw( EFalse );

    if( iSize != aSize )

        {

        // Let's save the required size for the iLocation

        iSize = aSize;

        if ( iObserver && aEdwin == iLocation )

           {

           iObserver->ControlSizeChanged( this );

           reDraw = ETrue;

           }

        if( iLocation->LineCount() != iLineCount )

            {

            // Line count has changed, the whole component needs

            // to be redrawn

            DrawDeferred();

            iLineCount = iLocation->LineCount();

            }

        }

    return reDraw;

    }

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

// CESMRLocationField::HandleEdwinEventL

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

//

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

    {

    FUNC_LOG;

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

        {

        TInt textLength( iLocation->TextLength() );

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

            {

            NotifyEventAsyncL( EESMRCmdSizeExceeded );

            }

        else if ( iWaypointIcon && textLength == 0 )

            {

            SetWaypointIconL( EFalse );

            NotifyEventL( EESMRCmdDisableWaypointIcon );

            }

        }

    }

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

// CESMRLocationField::GetCursorLineVerticalPos

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

//

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

    {

    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;

    }

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

// CESMRLocationField::SetWaypointIconL

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

//

void CESMRLocationField::SetWaypointIconL( TBool aEnabled )

    {

    delete iWaypointIcon;

    iWaypointIcon = NULL;

    if ( aEnabled )

        {

        iWaypointIcon = CMRImage::NewL(

                NMRBitmapManager::EMRBitmapLocationWaypoint,

                this,

                ETrue );

        }

    SizeChanged();

    }

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

// CESMRLocationField::CountComponentControls

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

//

TInt CESMRLocationField::CountComponentControls( ) const

    {

    FUNC_LOG;

    TInt count( 0 );

    if( iFieldButton )

        {

        ++count;

        }

    if ( iTitle )

        {

        ++count;

        }

    if( iLocation )

        {

        ++count;

        }

    if( iWaypointIcon )

        {

        ++count;

        }

    return count;

    }

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

// CESMRLocationField::ComponentControl

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

//

CCoeControl* CESMRLocationField::ComponentControl( TInt aInd ) const

    {

    FUNC_LOG;

    switch ( aInd )

        {

        case 0:

            return iFieldButton;

        case 1:

            return iTitle;

        case 2:

            return iLocation;

        case 3:

            return iWaypointIcon;

        default:

            return NULL;

        }

    }

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

// CESMRLocationField::SizeChanged

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

//

void CESMRLocationField::SizeChanged()

    {

    FUNC_LOG;

    TRect rect( Rect() );

    TAknLayoutRect firstRowLayoutRect(

            NMRLayoutManager::GetFieldRowLayoutRect( rect, 1 ) );

    TRect firstRowRect( firstRowLayoutRect.Rect() );

    TRect secondRowRect( firstRowRect );

    secondRowRect.Move( 0, firstRowRect.Height() );

    // Layout field button

    if( iFieldButton )

        {

        TAknWindowComponentLayout buttonLayout(

                NMRLayoutManager::GetWindowComponentLayout(

                    NMRLayoutManager::EMRLayoutTextEditorIcon ) );

        AknLayoutUtils::LayoutControl(

                iFieldButton, firstRowRect, buttonLayout );

        }

    // Layout field title

    if( iTitle )

        {

        TAknTextComponentLayout editorLayout =

                NMRLayoutManager::GetTextComponentLayout(

                        NMRLayoutManager::EMRTextLayoutTextEditor );

        AknLayoutUtils::LayoutLabel( iTitle, firstRowRect, editorLayout );

        }

    TRect editorRect( 0, 0, 0, 0 );

    // Layout field editor

    if( iLocation )

        {

        TAknLayoutText editorLayoutText;

        if( iWaypointIcon )

           {

           editorLayoutText = NMRLayoutManager::GetLayoutText(

                   secondRowRect,

                   NMRLayoutManager::EMRTextLayoutSingleRowEditorText );

           }

        else

           {

           editorLayoutText = NMRLayoutManager::GetLayoutText(

                   secondRowRect,

                   NMRLayoutManager::EMRTextLayoutTextEditor );

           }