/*

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

 *

*/

#include "emailtrace.h"

#include <calentry.h>

#include <StringLoader.h>

#include <esmrgui.rsg>

#include <AknUtils.h>

#include <AknsDrawUtils.h>

#include <AknsFrameBackgroundControlContext.h>

//<cmail>

#include "cesmrurlparserplugin.h"

//</cmail>

#include "cesmrdescriptionfield.h"

#include "mesmrlistobserver.h"

#include "cesmreditor.h"

#include "cesmrrichtextlink.h"

#include "cesmrlayoutmgr.h"

#include "esmrfieldbuilderdef.h"

#include "cesmrfeaturesettings.h"

#include "cesmrglobalnote.h"

namespace{ // codescanner::namespace

const TInt KFieldInnerShrink(3);

}//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 iFrameBgContext;

    delete iLocationLink;

    delete iFeatures;

    }

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

// CESMRDescriptionField::InitializeL

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

//

void CESMRDescriptionField::InitializeL()

    {

    FUNC_LOG;

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

    }

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

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

    if( buf )

        {

        CleanupStack::PushL( buf );

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

            {

            CCalEntry& entry = aEntry.Entry();

            HBufC* newBuf = AddLinkToTextL( *buf );

            if( newBuf )

                {

                CleanupStack::PopAndDestroy( buf );

                buf = newBuf;

                CleanupStack::PushL( buf );

                }

            entry.SetDescriptionL( *buf );

            }

        CleanupStack::PopAndDestroy( buf );

        }

    else if( iLocationLink )

        {

        CCalEntry& entry = aEntry.Entry();

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

        }

    else

        {

        CCalEntry& entry = aEntry.Entry();

        entry.SetDescriptionL( KNullDesC );

        }

    }

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

// CESMRDescriptionField::SetOutlineFocusL

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

//

void CESMRDescriptionField::SetOutlineFocusL( TBool aFocus )

    {

    FUNC_LOG;

    CESMRField::SetOutlineFocusL ( aFocus );

    if ( aFocus )

        {

        ChangeMiddleSoftKeyL(EESMRCmdSaveMR,R_QTN_MSK_SAVE);

        }

    }

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

// CESMRDescriptionField::ExpandedHeight

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

//

TInt CESMRDescriptionField::ExpandedHeight( ) const

    {

    FUNC_LOG;

    return iSize.iHeight;

    }

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

// CESMRDescriptionField::OfferKeyEventL

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

//

TKeyResponse CESMRDescriptionField::OfferKeyEventL(const TKeyEvent& aEvent,

        TEventCode aType )

    {

    FUNC_LOG;

    return iDescription->OfferKeyEventL( aEvent, aType );

    }

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

// CESMRDescriptionField::HandleEdwinSizeEventL

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

//

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

        TEdwinSizeEvent /*aType*/, TSize aSize )

    {

    FUNC_LOG;

    iSize = aSize;

    iSize.iHeight -= KEditorDifference;

    if (iLayout->CurrentFontZoom() == EAknUiZoomSmall ||

        iLayout->CurrentFontZoom() == EAknUiZoomVerySmall)

        {

        iSize.iHeight -= KEditorDifference;

        }

    if ( iObserver )

        {

        iObserver->ControlSizeChanged ( this );

        }

    if( iFrameBgContext )

        {

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

        iFrameBgContext->SetFrameRects( visibleRect, visibleRect );

        }

    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() :

    iSize( TSize( 0, 0 ))

    {

    FUNC_LOG;

    }

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

// CESMRDescriptionField::ActivateL

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

//

void CESMRDescriptionField::ActivateL()

    {

    FUNC_LOG;

    CCoeControl::ActivateL();

    TRect rect(TPoint(iDescription->Position()), iDescription->Size());

    TRect inner(rect);

    inner.Shrink( KFieldInnerShrink, KFieldInnerShrink );

    TRect outer(rect);

    delete iFrameBgContext;

    iFrameBgContext = NULL;

    iFrameBgContext = CAknsFrameBackgroundControlContext::NewL( KAknsIIDQsnFrInput, 

                                                                outer, 

                                                                inner, 

                                                                EFalse );

    iFrameBgContext->SetParentContext( iBackground );

    iDescription->SetSkinBackgroundControlContextL( iFrameBgContext );

    }

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

// CESMRDescriptionField::PositionChanged()

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

//

void CESMRDescriptionField::PositionChanged()

    {

    FUNC_LOG;

    CCoeControl::PositionChanged();

    if( iFrameBgContext )

        {

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

        iFrameBgContext->SetFrameRects( visibleRect, visibleRect );

        }

    }

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

// CESMRDescriptionField::ConstructL

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

//

void CESMRDescriptionField::ConstructL()

    {

    FUNC_LOG;

    SetFieldId( EESMRFieldDescription );

    SetExpandable( );

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

                                    CEikEdwin::EResizable |

                                    CEikEdwin::EAvkonEditor );

    iDescription->SetEdwinSizeObserver( this );

    iDescription->SetEdwinObserver( this );

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

    iDescription->SetDefaultTextL( buf ); // ownership transferred

    CleanupStack::Pop( buf );

    iBackground = AknsDrawUtils::ControlContext( this );

    CESMRField::ConstructL( iDescription );

    }

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

// CESMRDescriptionField::GetMinimumVisibleVerticalArea

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

//

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

    {

    FUNC_LOG;

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

    aUpper = aLower - iDescription->RowHeight();

    }

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

// CESMRDescriptionField::ListObserverSet

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

//

void CESMRDescriptionField::ListObserverSet()

    {

    FUNC_LOG;

    iDescription->SetListObserver( iObserver );

    }

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

// CESMRDescriptionField::StoreLinkL

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

//

void CESMRDescriptionField::StoreLinkL( MESMRCalEntry& aEntry )

    {

    FUNC_LOG;

    TInt command( EESMRCmdDisableWaypointIcon );

    CESMRUrlParserPlugin* urlParser = CESMRUrlParserPlugin::NewL();

    CleanupStack::PushL( urlParser );

    TPtrC urlPointer;

    TInt position;

    position = urlParser->FindLocationUrl( aEntry.Entry().DescriptionL(), 

                                           urlPointer );

    CleanupStack::PopAndDestroy( urlParser );

    if ( position >= KErrNone )

        {

        command = EESMRCmdEnableWaypointIcon;

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

        }

    NotifyEventL( command );

    }

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

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

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

//

void CESMRDescriptionField::ExecuteGenericCommandL( 

		TInt aCommand )

	{

    FUNC_LOG;

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

		}

	}

// EOF