/*

* Copyright (c) 2003-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

*

*/

#include "cesmrrichtextviewer.h"

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

#include "esmrconfig.hrh"

#include "esmrhelper.h"

#include "cesmriconfield.h"

#include "cesmrfieldcommandevent.h"

#include "mesmrfieldeventqueue.h"

#include "cesmrlayoutmgr.h"

#include "cesmrrichtextlink.h"

#include "cesmrcontactmenuhandler.h"

#include "nmrbitmapmanager.h"

#include <esmrgui.rsg>

#include <commonphoneparser.h>

#include <finditemengine.h>

#include <txtrich.h>

#include <AknsUtils.h>

#include <eikenv.h>

#include <data_caging_path_literals.hrh>

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

#include <aknlongtapdetector.h>

#include <touchfeedback.h>

#ifndef FF_CMAIL_INTEGRATION

#include <txtclipboard.h>

#endif // FF_CMAIL_INTEGRATION

// DEBUG

#include "emailtrace.h"

// <cmail> Removed profiling. </cmail>

// Unnamed namespace for local definitions

namespace{ // codescanner::namespace

const TInt KArrowUpperMargin (2);

const TInt KArrowRightMargin (5);

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

    delete iActionMenuIcon;

    delete iActionMenuIconMask;

    iESMRStatic.Close ( );

    delete iLongTapDetector;

    }

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

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

        }

    if ( IsFocused() )

        {

        if( iLayout )

            {

            TRAP_IGNORE( SetFontColorL( ETrue ) );

            }

        if ( iCurrentLinkIndex == KErrNotFound )

            {

            TInt linkRow = KErrNotFound;

            if ( CursorPos() == 0 )

                {

                // focus is coming from field above:

                linkRow = FindTextLinkBetweenNextScrollArea(

                		0, 1, TCursorPosition::EFLineDown );

                }

            else

                {

                linkRow = FindTextLinkBetweenNextScrollArea(

                		LineCount()-2,

                        LineCount()-1,

                        TCursorPosition::EFLineUp);

                }

            if ( linkRow != KErrNotFound )

                {

                const CESMRRichTextLink* link = GetSelectedLink ( );

                if (link )

                    {

                    HighlightLink (*link );

                    DrawDeferred ( );

                    }

                }

            }

        else

            {

            const CESMRRichTextLink* link = GetSelectedLink ( );

            }

        }

    if (!IsFocused())

        {

        // losing focus

        // <cmail> codescanner

		TRAP_IGNORE(SetSelectionL(CursorPos(), CursorPos()));

        if( iLayout )

            {

            TRAP_IGNORE(SetFontColorL( EFalse ));

            }

        // </cmail>

        TRAP_IGNORE( TextView()->SetDocPosL( 0 ));

        }

    }

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

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

                }

            }

    iCurrentLinkIndex = KErrNotFound;

    return linkRow;

    }

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

// CESMRRichTextViewer::ValidLinkForFocusing

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

//

TInt CESMRRichTextViewer::ValidLinkForFocusing(

        TInt aIndex,

        TCursorPosition::TMovementType aDirection,

        TInt aStartRow,

        TInt aEndRow )

    {

    FUNC_LOG;

    if(iLinkList.Count() > aIndex)

	    {

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

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

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

	        {

	        if ( aDirection == TCursorPosition::EFLineDown &&

	             aIndex > iCurrentLinkIndex  ||

	             aDirection == TCursorPosition::EFLineUp &&

	             ( aIndex < iCurrentLinkIndex ||

	               iCurrentLinkIndex == KErrNotFound ))

	            {

	            iCurrentLinkIndex = aIndex;

	            // link found between next scroll area.

	            return checkRow;

	            }

	        }

	    }

    return KErrNotFound;

    }

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

// CESMRRichTextViewer::SetHighLightToNextLinkL

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

//

TBool CESMRRichTextViewer::SetHighLightToNextLinkL(

        TCursorPosition::TMovementType aDirection,

        TInt aStartRow,

        TInt aEndRow )

    {

    FUNC_LOG;

    TBool ret( EFalse );

    TInt currentLineNumber = TextLayout()->GetLineNumber( CursorPos() );

    // check is there a link before next scroll point:

    TInt linkRow = FindTextLinkBetweenNextScrollArea(

						aStartRow , aEndRow, aDirection);

    if ( linkRow != KErrNotFound && iCurrentLinkIndex != KErrNotFound )

        {

        const CESMRRichTextLink* link = GetSelectedLink ( );

        if (link )

            {

            HighlightLink (*link );

            if ( iObserver && linkRow != currentLineNumber )

                {

                TInt endOfLink = link->StartPos()+link->Length();

                TInt line = TextLayout()->GetLineNumber( endOfLink );

                if ( aDirection == TCursorPosition::EFLineUp ) // moving up:

                    {

                    iObserver->MoveListAreaDownL(

                            RowHeight() * ( currentLineNumber - line ));

                    }

                else

                    {

                    iObserver->MoveListAreaUpL(

                            RowHeight() * ( line - currentLineNumber ));

                    }

                }

            DrawDeferred ( );

            ret = ETrue;

            }

        }

    else

    	{

    	// no link are focused, do reset work to refresh the option menu.

    	ResetActionMenuL();

    	}

    return ret;

    }

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

// CESMRRichTextViewer::OfferKeyEventL

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

//

EXPORT_C TKeyResponse CESMRRichTextViewer::OfferKeyEventL(

        const TKeyEvent &aKeyEvent,

        TEventCode aType )

    {

    FUNC_LOG;

    // Handle only event keys

    if ( aType == EEventKey )

        {

        if ( iObserver ) // only description field has observer set.

            {

            // fetch the current line number:

            TInt currentLineNumber = TextLayout()->GetLineNumber( CursorPos() );

            if ( aKeyEvent.iCode == EKeyDownArrow && aType == EEventKey )

                {

                if ( !iObserver->IsFieldBottomVisible() &&

                     SetHighLightToNextLinkL(

                    		 TCursorPosition::EFLineDown,

                             currentLineNumber,

                             currentLineNumber + KMaxAddressFieldLines) )

                    {

                    return EKeyWasConsumed;

                    }

                else if ( iObserver->IsFieldBottomVisible() )

                    {

                    if ( SetHighLightToNextLinkL(TCursorPosition::EFLineDown,

                                            currentLineNumber,

                                            iNumberOfLines) )

                        {

                        return EKeyWasConsumed;

                        }

                    // means that the whole control is visible:

                    // and we can skip to next field

                    return EKeyWasNotConsumed;

                    }

                if ( currentLineNumber == iNumberOfLines )

                    {

                    // the end of text has been reached

                    return EKeyWasConsumed;

                    }

                // move three lines...

                ScrollViewL( KMaxAddressFieldLines,

							 TCursorPosition::EFLineDown);

                SetSelectionL( CursorPos(), CursorPos() );

                iCurrentLinkIndex = KErrNotFound;

                if ( iObserver )

                    {

                    iObserver->MoveListAreaUpL(

                    		RowHeight() * KMaxAddressFieldLines );

                    }

                return EKeyWasConsumed;

                }

            else if ( aKeyEvent.iCode == EKeyUpArrow && aType == EEventKey )

                {

                if (iPosition.iY < 0 &&

                    SetHighLightToNextLinkL(

                    		TCursorPosition::EFLineUp,

                            currentLineNumber - KMaxAddressFieldLines,

                            currentLineNumber))

                    {

                    return EKeyWasConsumed;

                    }

                if ( iPosition.iY > 0 )

                    {

                    // before changing the focus the field above,

                    // check is there any links in rest of text

                    if (SetHighLightToNextLinkL(TCursorPosition::EFLineUp,

                                        0,

                                        currentLineNumber))

                        {

                        return EKeyWasConsumed;

                        }

                    // means that the whole control is visible:

                    // and we can skip to next field

                    return EKeyWasNotConsumed;

                    }

                else

                    {

                    TInt currentLineNumber =

                    TextLayout()->GetLineNumber( CursorPos() );

                    // move three lines...

                    ScrollViewL( KMaxAddressFieldLines,

                    		     TCursorPosition::EFLineUp);

                    SetSelectionL( CursorPos(), CursorPos());

                    iCurrentLinkIndex = KErrNotFound;

                     if ( iObserver )

                        {

                        iObserver->MoveListAreaDownL(

                        		RowHeight() * KMaxAddressFieldLines );

                        }

                    currentLineNumber =

						TextLayout()->GetLineNumber( CursorPos() );

                    return EKeyWasConsumed;

                    }

                }

            }

        if ( aKeyEvent.iCode == EKeyRightArrow ||

        	 aKeyEvent.iCode == EKeyDevice3 ||

             aKeyEvent.iCode == EKeyDevice4 ||

             aKeyEvent.iCode == EKeyEnter )

            {

            // Show right click menu (action menu)

            const CESMRRichTextLink* link = GetSelectedLink();

            if (link &&

            	link->TriggerKey ( )== CESMRRichTextLink::ETriggerKeyRight )

                {

                if ( !iLinkObserver ||

                	 !iLinkObserver->HandleRichTextLinkSelection(link) )

                    {

                    iCntMenuHdlr->ShowActionMenuL();

                    }

                return EKeyWasConsumed;

                }

            }

        if ( aKeyEvent.iCode == EKeyLeftArrow )

            {

            const CESMRRichTextLink* link = GetSelectedLink();

            if ( link )

                {

                return EKeyWasConsumed;

                }

            }

        if ( aKeyEvent.iCode == EKeyDevice3 ||

        		aKeyEvent.iCode == EKeyDevice4 ||

        		aKeyEvent.iCode == EKeyEnter )

            {

            // Select link

            const CESMRRichTextLink* link = GetSelectedLink ( );

            if (link &&

            	link->TriggerKey ( )== CESMRRichTextLink::ETriggerKeyOk )

                {

                if (iLinkObserver &&

                	iLinkObserver->HandleRichTextLinkSelection (link ) )

                    {

                    return EKeyWasConsumed;

                    }

                }

            }

        }

    return EKeyWasNotConsumed;

    }

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

// CESMRRichTextViewer::ScrollViewL

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

//

void CESMRRichTextViewer::ScrollViewL(

        TInt aNumberOfRows,

        TCursorPosition::TMovementType aDirection)

    {

    FUNC_LOG;

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

        {

        MoveCursorL( aDirection, EFalse);

        }

    }

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

// CESMRRichTextViewer::SetMargins

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

//

EXPORT_C void CESMRRichTextViewer::SetMargins( TInt sMargin )

	{

	// Set new value for left and right margins

	if ( TextView() )

	    {

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

	    }

	}

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

// CESMRRichTextViewer::SetFontL

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

//

EXPORT_C void CESMRRichTextViewer::SetFontL( const CFont* aFont,

                                             CESMRLayoutManager* aLayout )

    {

    FUNC_LOG;

    // These pointers are stored to able font color changing when losing or

    // gaining focus

    iLayout = aLayout;

    iFont = aFont;

    SetFontColorL( IsFocused() );

    // This forces CEikEdwin::OnReformatL to notify observer

    // through HandleEdwinSizeEventL about changed size.

    // It is notified only if linecount changes.

    CEikEdwin::iNumberOfLines = 0;

    CEikEdwin::FormatTextL();

    }

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

// CESMRRichTextViewer::SetFontColor

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

//

void CESMRRichTextViewer::SetFontColorL( TBool aFocused )

    {

    FUNC_LOG;

    // all this stuff is needed to be set, otherwise the

    // font loses its antialiasing drawing

    TFontSpec fontSpec = iFont->FontSpecInTwips();

    CParaFormat paraFormat;

    TParaFormatMask paraFormatMask;

    paraFormat.iLineSpacingControl = CParaFormat::ELineSpacingExactlyInPixels;