/*

* 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 Description (summary) field implementation

 *

*/

#include "cesmrdescriptionfield.h"

#include "mesmrlistobserver.h"

#include "cesmreditor.h"

#include "cesmrrichtextlink.h"

#include "esmrfieldbuilderdef.h"

#include "cesmrfeaturesettings.h"

#include "cesmrglobalnote.h"

#include "nmrlayoutmanager.h"

#include "nmrbitmapmanager.h"

//<cmail>

#include "cesmrurlparserplugin.h"

//</cmail>

#include <calentry.h>

#include <StringLoader.h>

#include <esmrgui.rsg>

#include <AknUtils.h>

#include <AknsBasicBackgroundControlContext.h>

#include <eikmfne.h>

// DEBUG

#include "emailtrace.h"

namespace // codescanner::namespace

    {

    /// Field's component count, iDescription

    const TInt KComponentCount( 1 );

    }//namespace

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

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

// CESMRDescriptionField::NewL

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

//

CESMRDescriptionField* CESMRDescriptionField::NewL( )

    {

    FUNC_LOG;

    CESMRDescriptionField* self = new (ELeave) CESMRDescriptionField;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CESMRDescriptionField::~CESMRDescriptionField

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

//

CESMRDescriptionField::~CESMRDescriptionField( )

    {

    FUNC_LOG;

    delete iLocationLink;

    delete iFeatures;

    delete iBgControlContext;

    delete iUrlParser;

    }

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

// CESMRDescriptionField::InitializeL

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

//

void CESMRDescriptionField::InitializeL()

    {

    FUNC_LOG;

    // Do nothing

    }

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

// CESMRDescriptionField::InternalizeL

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

//

void CESMRDescriptionField::InternalizeL( MESMRCalEntry& aEntry )

    {

    FUNC_LOG;

    CCalEntry& entry = aEntry.Entry ( );

    HBufC* summary = entry.DescriptionL().AllocLC ( );

    // externalize is done only when there is text and its NOT the default one.

    if ( summary->Length ( )> 0 &&

            iDescription->DefaultText().Compare (*summary )!= 0 )

        {

        iDescription->ClearSelectionAndSetTextL ( *summary );

        if ( FeaturesL().FeatureSupported(

                CESMRFeatureSettings::EESMRUIMnFwIntegration ) )

            {

            StoreLinkL( aEntry );

            }

        }

    CleanupStack::PopAndDestroy ( summary );

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

    // does not get correctly instantiated with default text

    iDescription->FocusChanged(EDrawNow);

    }

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

// CESMRDescriptionField::ExternalizeL

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

//

void CESMRDescriptionField::ExternalizeL( MESMRCalEntry& aEntry )

    {

    FUNC_LOG;

    HBufC* buf = iDescription->GetTextInHBufL();

    CCalEntry& entry = aEntry.Entry();

    if( buf )

        {

        CleanupStack::PushL( buf );

        if( iDescription->DefaultText().Compare( *buf ) != 0 )

            {

            // Edited text. Add link to description text

            HBufC* newBuf = AddLinkToTextL( *buf );

            if( newBuf )

                {

                CleanupStack::PopAndDestroy( buf );

                buf = newBuf;

                CleanupStack::PushL( buf );

                }

            entry.SetDescriptionL( *buf );

            }

        else if ( iLocationLink )

            {

            // Location link set

            entry.SetDescriptionL( iLocationLink->Value() );

            }

        else if ( entry.DescriptionL().Length() != 0 )

            {

            // Clear old description

            entry.SetDescriptionL( KNullDesC );

            }

        CleanupStack::PopAndDestroy( buf );

        }

    else if( iLocationLink )

        {

        entry.SetDescriptionL( iLocationLink->Value() );

        }

    else

        {

        entry.SetDescriptionL( KNullDesC );

        }

    }

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

// CESMRDescriptionField::SetOutlineFocusL

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

//

void CESMRDescriptionField::SetOutlineFocusL( TBool aFocus )

    {

    FUNC_LOG;

    CESMRField::SetOutlineFocusL ( aFocus );

    if ( aFocus )

        {

        ChangeMiddleSoftKeyL(EESMRCmdSaveMR,R_QTN_MSK_SAVE);

        }

    }

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

// CESMRDescriptionField::OfferKeyEventL

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

//

TKeyResponse CESMRDescriptionField::OfferKeyEventL(const TKeyEvent& aEvent,

        TEventCode aType )

    {

    FUNC_LOG;

    TKeyResponse response( EKeyWasNotConsumed);

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

    if ( aType == EEventKey &&

         ( aEvent.iScanCode != EStdKeyUpArrow &&

          aEvent.iScanCode != EStdKeyDownArrow ))

        {

        iDescription->DrawDeferred();

        }

    return response;

    }

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

// CESMRDescriptionField::HandleEdwinSizeEventL

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

//

TBool CESMRDescriptionField::HandleEdwinSizeEventL(CEikEdwin* /*aEdwin*/,

        TEdwinSizeEvent /*aType*/, TSize aSize )

    {

    FUNC_LOG;

    if ( aSize != iSize )

        {

        iSize = aSize;

        if ( iObserver )

            {

            iObserver->ControlSizeChanged ( this );

            }

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

            {

            // Line count has changed, the whole component needs

            // to be redrawn

            DrawDeferred();

            // Also if new line count is less than previous one, we

            // need to redraw the parent also (this is the last field).

            // Otherwise the removed line will remain on the screen

            // until parent is redrawn.

            if( iDescription->LineCount() < iLineCount )

                {

                Parent()->DrawDeferred();

                }

            iLineCount = iDescription->LineCount();

            }

        }

    return ETrue;

    }

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

// CESMRDescriptionField::HandleEdwinEventL

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

//

void CESMRDescriptionField::HandleEdwinEventL(

        CEikEdwin* aEdwin,TEdwinEvent aEventType)

    {

    FUNC_LOG;

    if ( aEdwin == iDescription

         && aEventType == EEventTextUpdate )

        {

        HBufC* text = iDescription->GetTextInHBufL();

        if ( text )

            {

            CleanupStack::PushL( text );

            TInt textLength( text->Length() );

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

                {

                NotifyEventAsyncL( EESMRCmdSizeExceeded );

                }

            CleanupStack::PopAndDestroy( text );

            }

        }

    }

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

// CESMRDescriptionField::CESMRDescriptionField

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

//

CESMRDescriptionField::CESMRDescriptionField()

    {

    FUNC_LOG;

    SetFieldId( EESMRFieldDescription );

    SetFocusType( EESMRHighlightFocus );

    }

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

// CESMRDescriptionField::ConstructL

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

//

void CESMRDescriptionField::ConstructL()

    {

    FUNC_LOG;

    iDescription = CESMREditor::NewL( this, 1, KTextLimit,

                                    CEikEdwin::EResizable |

                                    CEikEdwin::EAvkonEditor );

    iDescription->SetEdwinSizeObserver( this );

    iDescription->SetEdwinObserver( this );

    CESMRField::ConstructL( iDescription );

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

    iDescription->SetDefaultTextL( buf ); // ownership 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 );

    iDescription->SetSkinBackgroundControlContextL( iBgControlContext );

    }

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

// CESMRDescriptionField::ListObserverSet

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

//

void CESMRDescriptionField::ListObserverSet()

    {

    FUNC_LOG;

    iDescription->SetListObserver( iObserver );

    }

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

// CESMRDescriptionField::GetCursorLineVerticalPos

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

//

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

    {

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

    aUpper = aLower - iDescription->RowHeight();

    }

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

// CESMRDescriptionField::StoreLinkL

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

//

void CESMRDescriptionField::StoreLinkL( MESMRCalEntry& aEntry )

    {

    FUNC_LOG;

    TPtrC urlPointer;

    TInt position;

    position = UrlParserL().FindLocationUrl( aEntry.Entry().DescriptionL(),

                                           urlPointer );

    if ( position >= KErrNone )

        {

        HBufC* description =

            HBufC::NewL( aEntry.Entry().DescriptionL().Length() );

        CleanupStack::PushL( description );

        TPtr descriptionPointer( description->Des() );

        descriptionPointer.Append( aEntry.Entry().DescriptionL() );

        descriptionPointer.Delete( position, urlPointer.Length() );

        descriptionPointer.TrimLeft();

        if ( description->Length() != 0 )

            {

            iDescription->ClearSelectionAndSetTextL( *description );

            }

        else

            {

            iDescription->ClearSelectionAndSetTextL(

                    iDescription->DefaultText() );

            }

        CleanupStack::PopAndDestroy( description );

        if ( iLocationLink )

            {

            delete iLocationLink;

            iLocationLink = NULL;

            }

        HBufC* showOnMapBuf =

            StringLoader::LoadLC( R_MEET_REQ_LINK_SHOW_ON_MAP );

        iLocationLink = CESMRRichTextLink::NewL( position,

                                     showOnMapBuf->Length(),

                                     urlPointer,

                                     CESMRRichTextLink::ETypeLocationUrl,

                                     CESMRRichTextLink::ETriggerKeyOk );

        CleanupStack::PopAndDestroy( showOnMapBuf );

        StoreGeoValueL( aEntry.Entry(),

                        urlPointer );

        }

    }

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

// CESMRDescriptionField::AddLinkToTextL

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

//

HBufC* CESMRDescriptionField::AddLinkToTextL( const TDesC& aBuf )

    {

    FUNC_LOG;

    if( iLocationLink )

        {

        TInt newTextLen = aBuf.Length() + iLocationLink->Value().Length() + 1;

        HBufC* retBuf = HBufC::NewL( newTextLen );

        retBuf->Des().Append( iLocationLink->Value() );

        _LIT( KParagraphSeparator, "\x2029" ); // unicode paragraph separator

        // add the separator after url

        retBuf->Des().Append( KParagraphSeparator );

        retBuf->Des().Append( aBuf );

        return retBuf;

        }

    else

        {

        return NULL;

        }

    }

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

// CESMRDescriptionField::FeaturesL

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

//

CESMRFeatureSettings& CESMRDescriptionField::FeaturesL()

    {

    FUNC_LOG;

    if ( !iFeatures )

        {

        iFeatures = CESMRFeatureSettings::NewL();

        }

    return *iFeatures;

    }

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

// CESMRDescriptionField::ExecuteGenericCommandL

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

//

TBool CESMRDescriptionField::ExecuteGenericCommandL(

        TInt aCommand )

    {

    FUNC_LOG;

    TBool isUsed( EFalse );

    if ( EESMRCmdSizeExceeded == aCommand )

        {

        CESMRGlobalNote::ExecuteL(

                CESMRGlobalNote::EESMRCannotDisplayMuchMore );

        HBufC* text = iDescription->GetTextInHBufL();

        CleanupDeletePushL( text );

        if ( text )

            {

            TInt curPos = iDescription->CursorPos();

            if( curPos > iDescription->GetLimitLength() - 1 )

                curPos = iDescription->GetLimitLength() - 1;

            HBufC* newText =

                text->Des().Mid( 0,

                        iDescription->GetLimitLength() - 1 ).AllocLC();

            iDescription->SetTextL ( newText );

            CleanupStack::PopAndDestroy( newText );

            newText = NULL;

            iDescription->SetCursorPosL (curPos, EFalse );

            iDescription->HandleTextChangedL();

            iDescription->UpdateScrollBarsL();

            SetFocus(ETrue);

            }

        CleanupStack::PopAndDestroy( text );

        isUsed = ETrue;

        }

    else if ( EESMRCmdDisableWaypointIcon == aCommand )

        {

        isUsed = ETrue;

        // Clear location link

        delete iLocationLink;

        iLocationLink = NULL;

        }

    return isUsed;

    }

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

// CESMRDescriptionField::CountComponentControls

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

//

TInt CESMRDescriptionField::CountComponentControls() const

    {

    return KComponentCount;

    }

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

// CESMRDescriptionField::ComponentControl

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

//

CCoeControl* CESMRDescriptionField::ComponentControl( TInt aInd ) const

    {

    if( aInd == 0 )

        {

        return iDescription;

        }

    return NULL;

    }

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

// CESMRDescriptionField::SizeChanged

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

//

void CESMRDescriptionField::SizeChanged()

    {

    TRect rect( Rect() );

    // Optimization: Layouting only when necessary

    if( iFieldRect != rect )

        {

        rect = NMRLayoutManager::GetFieldRowLayoutRect( rect, 1 ).Rect();

        TAknLayoutText editorLayoutText = NMRLayoutManager::GetLayoutText(

                        rect,

                        NMRLayoutManager::EMRTextLayoutMultiRowTextEditor );

        TRect editorRect = editorLayoutText.TextRect();

        TRect bgRect( editorRect );

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

        bgRect.Move( -Position() );

        if( iSize.iHeight > 0 )

            {

            bgRect.SetHeight( iSize.iHeight );

            }

        SetFocusRect( bgRect );

        iDescription->SetRect(

                TRect( editorRect.iTl,

                        TSize( editorRect.Width(), iSize.iHeight ) ) );

        // Set also correct font for description field

        TRAP_IGNORE( iDescription->SetFontL( editorLayoutText.Font() ) );

        iFieldRect = rect;

        }

    }

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

// CESMRDescriptionField::MinimumSize

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

//