/*

* 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 : CEikRichTextEditor based Rich Text viewer

*  Version     : %version: e002sa33#45.3 %

*

*/

#include "cesmrrichtextviewer.h"

#include "mesmrlistobserver.h"// SCROLLING_MOD: List observer header

#include "esmrconfig.hrh"

#include "esmrhelper.h"

#include "cesmrfieldcommandevent.h"

#include "mesmrfieldeventqueue.h"

#include "cesmrrichtextlink.h"

#include "cesmrcontactmenuhandler.h"

#include "nmrbitmapmanager.h"

#include "nmrcolormanager.h"

#include "esmrfieldbuilderdef.h"

#include "cesmrfield.h"

#include <esmrgui.rsg>

#include <commonphoneparser.h>

#include <finditemengine.h>

#include <txtrich.h>

#include <AknsUtils.h>

#include <AknBidiTextUtils.h>

#include <AknUtils.h>

#include <eikenv.h>

#include <data_caging_path_literals.hrh>

#include <baclipb.h> // for clipboard copy

#include <txtclipboard.h>

// DEBUG

#include "emailtrace.h"

// Unnamed namespace for local definitions

namespace{ // codescanner::namespace

#ifdef _DEBUG

    enum TPanic

        {

        EParaFormatNotInitialised = 1

        };

    void Panic( TPanic aPanic )

        {

        _LIT( KCategory, "CESMRRichTextViewer" );

        User::Panic( KCategory(), aPanic );

        }

#endif // DEBUG

// Side margin in twips, needed because not possible to set it in pixels

const TInt KDefaultTextSideMargin( 1 );

}//namespace

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

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

// CESMRRichTextViewer::NewL

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

//

EXPORT_C CESMRRichTextViewer* CESMRRichTextViewer::NewL(

        const CCoeControl* aParent)

    {

    FUNC_LOG;

    CESMRRichTextViewer* self = new (ELeave) CESMRRichTextViewer;

    CleanupStack::PushL ( self );

    self->ConstructL( aParent );

    CleanupStack::Pop ( self );

    return self;

    }

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

// CESMRRichTextViewer::~CESMRRichTextViewer

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

//

EXPORT_C CESMRRichTextViewer::~CESMRRichTextViewer( )

    {

    FUNC_LOG;

    iLinkList.ResetAndDestroy ( );

    iESMRStatic.Close ( );

    delete iParaFormat;

    }

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

// CESMRRichTextViewer::PositionChanged

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

//

EXPORT_C void CESMRRichTextViewer::PositionChanged( )

    {

    FUNC_LOG;

    CTextView* view = TextView ( );

    if ( view )

        {

        view->SetViewRect ( Rect ( ) );

        }

    }

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

// CESMRRichTextViewer::FocusChanged

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

//

EXPORT_C void CESMRRichTextViewer::FocusChanged(

        TDrawNow aDrawNow )

    {

    FUNC_LOG;

    CEikRichTextEditor::FocusChanged( aDrawNow );

    if ( !TextLayout() || !TextView() )

        {

        // not constructed totally:

        return;

        }

    // Check the current selection.

    // If a link has been highlighted, don't change it.

    TCursorSelection selection = Selection();

    // Gaining focus

    if ( IsFocused()

         && iLinkList.Count() > 0

         && ( selection.Length() == 0 ) )

        {

        // We need the field indexes, cast required

        CESMRField* parent = static_cast< CESMRField* >( Parent() );

        iCntMenuHdlr->SetContactMenuObserver( this );

        // Focus coming from above ...

        if( parent->CurrentItemIndex() > parent->PreItemIndex() )

            {

            // ... Highlight first link

            TRAP_IGNORE( HighlightLinkL( *( iLinkList[0] ) ) );

            }

        // Focus coming from below ...

        else

            {

            // ... Highlight last link

            TRAP_IGNORE( HighlightLinkL( *( iLinkList[iLinkList.Count() - 1 ] ) ) );

            }

        DrawDeferred();

        }

    // Losing focus

    if ( !IsFocused() )

        {

        TRAP_IGNORE(

                SetSelectionL( CursorPos(), CursorPos() );

                ResetActionMenuL();

                );

        }

    }

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

// CESMRRichTextViewer::FindTextLinkBetweenNextScrollArea

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

//

TInt CESMRRichTextViewer::FindTextLinkBetweenNextScrollArea(

        TInt aStartRow,

        TInt aEndRow,

        TCursorPosition::TMovementType aDirection)

    {

    FUNC_LOG;

    TInt linkRow(KErrNotFound);

    // fetch the line number where the next link is located:

    if ( aDirection == TCursorPosition::EFLineDown )

        {

        for (TInt i = 0; i<iLinkList.Count(); i++)

            {

            linkRow = ValidLinkForFocusing(i, aDirection, aStartRow, aEndRow);

            if ( linkRow != KErrNotFound)

                {

                return linkRow;

                }

            }

        }

    else

        for (TInt i = iLinkList.Count()-1; i>=0 ; i--)

            {

            linkRow = ValidLinkForFocusing(i, aDirection, aStartRow, aEndRow);

            if ( linkRow != KErrNotFound)

                {

                return linkRow;

                }

            }

    return linkRow;

    }

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

// CESMRRichTextViewer::ValidLinkForFocusing

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

//

TInt CESMRRichTextViewer::ValidLinkForFocusing(

        TInt aIndex,

        TCursorPosition::TMovementType aDirection,

        TInt aStartRow,

        TInt aEndRow )

    {

    FUNC_LOG;

    if ( iLinkList.Count() > aIndex)

	    {

	    TInt currPos( KErrNotFound );

        const CESMRRichTextLink* currentLink = GetSelectedLink();

        if ( currentLink )

            {

            currPos = currentLink->StartPos();

            }

        TInt pos = iLinkList[ aIndex ]->StartPos();

	    TInt checkRow = TextLayout()->GetLineNumber( pos );

	    if ( checkRow >= aStartRow && checkRow <= aEndRow )

	        {

	        if ( aDirection == TCursorPosition::EFLineDown &&

	             pos > currPos ||

	             aDirection == TCursorPosition::EFLineUp &&

	             ( pos < currPos || currPos == KErrNotFound ) )

	            {

	            // link found between next scroll area.

	            return checkRow;

	            }

	        }

	    }

    return KErrNotFound;

    }

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

// CESMRRichTextViewer::OfferKeyEventL

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

//

EXPORT_C TKeyResponse CESMRRichTextViewer::OfferKeyEventL(

        const TKeyEvent &aKeyEvent,

        TEventCode aType )

    {

    FUNC_LOG;

    TKeyResponse response( EKeyWasNotConsumed );

    // Handle only event keys.

    if( aType != EEventKey )

        {

        return response;

        }

    /*

     * Handles scrolling between rich text links.

     */

    const CESMRRichTextLink* selectedLink = GetSelectedLink();

    TInt linkCount = iLinkList.Count();

    // If a link is selected, it means that we are operating within

    // the field and can move focus between the links.

    if( linkCount && selectedLink )

        {

        TInt selectedLinkIndex = iLinkList.Find( selectedLink );

        switch ( aKeyEvent.iCode )

            {

            case EKeyLeftArrow:

            case EKeyUpArrow:

                {

                // If possible and exists ...

                if( selectedLinkIndex > 0 &&

                        selectedLinkIndex < linkCount )

                    {

                    // ...Highlight previous link.

                    HighlightLinkL( *( iLinkList[ selectedLinkIndex - 1 ] ) );

                    response = EKeyWasConsumed;

                    // View update required, for example if link is out of

                    // viewable area.

                    UpdateViewL( aKeyEvent );

                    }

                break;

                }

            case EKeyRightArrow:

            case EKeyDownArrow:

                {

                // If possible and exists ...

                if( selectedLinkIndex + 1 < linkCount &&

                        selectedLinkIndex >= 0 )

                    {

                    // ...Highlight next link.

                    HighlightLinkL( *( iLinkList[ selectedLinkIndex + 1 ] ) );

                    response = EKeyWasConsumed;

                    // View update required, for example if link is out of

                    // viewable area.

                    UpdateViewL( aKeyEvent );

                    }

                break;

                }

            case EKeyDevice3: // Selection key

            case EKeyEnter:

                {

                LinkSelectedL();

                response = EKeyWasConsumed;

                break;

                }

            default:

                break;

            }

        }

    return response;

    }

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

// CESMRRichTextViewer::HandlePointerEventL

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

//

void CESMRRichTextViewer::HandlePointerEventL( const TPointerEvent& aPointerEvent )

    {

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

        {

        TBool linkFound( EFalse );

        switch ( aPointerEvent.iType )

            {

            case TPointerEvent::EButton1Down:

                {

                RRegion linkArea;

                CleanupClosePushL( linkArea );

                // Find matching link

                TInt count = iLinkList.Count();

                for ( TInt i = 0; i < count; ++i )

                    {

                    CESMRRichTextLink* link = iLinkList[ i ];

                    GetLinkAreaL( linkArea, *link );

                    if ( linkArea.Contains( aPointerEvent.iPosition ) )

                        {

                        if ( link != GetSelectedLink() )

                            {

                            iCntMenuHdlr->Reset();

                            iCntMenuHdlr->SetContactMenuObserver( this );

                            HighlightLinkL( *link );

                            DrawDeferred();

                            }

                        linkFound = ETrue;

                        break;

                        }

                    }

                CleanupStack::PopAndDestroy( &linkArea );

                break;

                }

            case TPointerEvent::EButton1Up:

                {

                const CESMRRichTextLink* link = GetSelectedLink();

                TBool menuAvailable = iCntMenuHdlr->OptionsMenuAvailable();

                if ( link

                     && ( menuAvailable

                     || link->Type() == CESMRRichTextLink::ETypeLocationUrl

                     || link->Type() == CESMRRichTextLink::ETypeAttachment

                     || link->Type() == CESMRRichTextLink::ETypeShowAll ) )

                    {

                    linkFound = ETrue;

                    LinkSelectedL();

                    }

                else if ( link && !menuAvailable )

                    {

                    linkFound = ETrue;

                    iOpenActionMenu = ETrue;

                    }

                break;

                }

            default:

                {

                break;

                }

            }

        if ( !linkFound && TPointerEvent::EDrag != aPointerEvent.iType )

            {

            // Tap on plain text

            TextView()->ClearSelectionL();

            ResetActionMenuL();

            DrawDeferred();

            }

        }

    }

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

// CESMRRichTextViewer::SetMargins

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

//

EXPORT_C void CESMRRichTextViewer::SetMargins( TInt sMargin )

	{

	// Set new value for left and right margins

    TextView()->SetMarginWidths( sMargin ,0);

	}

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

// CESMRRichTextViewer::SetTextL

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

//

EXPORT_C void CESMRRichTextViewer::SetTextL(

        const TDesC* aText,

        TBool aSearchLinks )

    {

    FUNC_LOG;

    iLinkList.ResetAndDestroy();

    TextView()->SetMarginWidths( KDefaultTextSideMargin ,0);

    // Clear edwin text

    CEikEdwin::SetCursorPosL( 0, EFalse );

    CEikRichTextEditor::SetTextL( &KNullDesC );

    RichText()->Reset();

    // text lenght plus one to ensure the formatting

    // used is full, not band formatting.

    SetUpperFullFormattingLength( aText->Length() + 1 );

    // Set new edwin text

    CEikEdwin::SetTextLimit( aText->Length ( ) );

    CEikRichTextEditor::SetTextL( aText );

    //Make sure cursor is invisible and selection visible

    TextView()->SetCursorVisibilityL(

            TCursor::EFCursorInvisible,

            TCursor::EFCursorInvisible );

    TextView()->SetSelectionVisibilityL( ETrue );

    // Search text for links (highlights)

    if ( aSearchLinks )

        {

        SearchLinksL( *aText );

        // find first link.

        FindTextLinkBetweenNextScrollArea(0, KMaxAddressFieldLines, TCursorPosition::EFLineDown);

        }

    }

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

// CESMRRichTextViewer::SetLinkObserver

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

//

EXPORT_C void CESMRRichTextViewer::SetLinkObserver(

        MESMRRichTextObserver* aLinkObserver )

    {

    FUNC_LOG;

    iLinkObserver = aLinkObserver;

    }

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

// CESMRRichTextViewer::AddLinkL

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

//

EXPORT_C void CESMRRichTextViewer::AddLinkL( CESMRRichTextLink* aLink )

    {

    FUNC_LOG;

    // If this is first link, set it highlighted

    TBool highlight = IsFocused()&& ( iLinkList.Count() == 0 );

    // Reserve space for new link

    iLinkList.ReserveL( iLinkList.Count() + 1 );

    RichText()->ApplyCharFormatL( iRichTextLinkFormat,

                                  iRichTextLinkFormatMask,

                                  aLink->StartPos(),

                                  aLink->Length() );

    // Append aLink to link list. Space has been reserved, so this cannot fail.

    iLinkList.AppendL( aLink );

    if ( highlight )

        {

        HighlightLinkL( *aLink );

        }

    }

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

// CESMRRichTextViewer::InsertLinkL

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

//

EXPORT_C void CESMRRichTextViewer::InsertLinkL( CESMRRichTextLink* aLink,

                                                TInt aPosition )

    {

    FUNC_LOG;

    // If this is first link, set it highlighted

    TBool highlight = IsFocused()&& ( iLinkList.Count() == 0 );

    // Reserve space for new link

    iLinkList.ReserveL( iLinkList.Count() + 1 );

    RichText()->ApplyCharFormatL( iRichTextLinkFormat,

                                  iRichTextLinkFormatMask,

                                  aLink->StartPos(),

                                  aLink->Length() );

    // Insert aLink to link list. Space has been reserved, so this cannot fail.

    // InsertL panics if aPosition is illegal.

    iLinkList.InsertL( aLink, aPosition );

    if ( highlight )

        {

        HighlightLinkL( *aLink );

        }

    }