/*

* Copyright (c) 2002-2007 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:  Plugin utility used for automatic tags ( http, email, phone numbers, URI schemes )

*                syntax highlighting in text viewers

*

*

*/

// INCLUDES

#include <eikrted.h>

#include <txtrich.h> // for CRichText

#include <finditemengine.h>

#include <commonphoneparser.h>

#include <txtfrmat.h>

#include <AknUtils.h> // for AknUtils

#include <AknsUtils.h>

// scheme recog

#include <ecom/ecom.h>

#include <ecom/implementationinformation.h>

#include <centralrepository.h>

#include <CommonUiInternalCRKeys.h>

// CONSTANTS

const TInt KMINTAGLENGTH(5);

_LIT( KHTTPPREFIX, "http://");

_LIT( RTSP, "rtsp");

_LIT( KTELPREFIX, "tel:");

const TInt KItemFinderMinDigitsToFind = 5;

#define SCHEME_INTERFACE_DEF TUid( TUid::Uid(0x101f8534) ) // we don't want header dependency to browser utilities

NONSHARABLE_CLASS(CSchemeResolver): public CBase

    {

public:

    CSchemeResolver(){};

    static CSchemeResolver* NewL();

    inline CArrayPtrFlat<HBufC>& SupportedSchemes(){ return *iSupportedArray; };

    ~CSchemeResolver();

private:

    void ConstructL();

    CArrayPtrFlat<HBufC>* iSupportedArray;

    RImplInfoPtrArray iEcomInfoArray;

    };

CSchemeResolver* CSchemeResolver::NewL()

    {

    CSchemeResolver* me = new (ELeave) CSchemeResolver();

    CleanupStack::PushL( me );

    me->ConstructL();

    CleanupStack::Pop();

    return me;

    }

void CSchemeResolver::ConstructL()

    {

    //perform plugin scan

    iSupportedArray = new (ELeave) CArrayPtrFlat<HBufC>( 5 );

    REComSession::ListImplementationsL( SCHEME_INTERFACE_DEF, iEcomInfoArray );

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

        {

        HBufC* data = HBufC::NewLC( iEcomInfoArray[ i ]->DataType().Length() );

        data->Des().Copy( iEcomInfoArray[ i ]->DataType() );

        iSupportedArray->AppendL( data );

        CleanupStack::Pop();

        }

    iEcomInfoArray.ResetAndDestroy(); // we don't need this anymore

    }

CSchemeResolver::~CSchemeResolver()

    {

    iEcomInfoArray.ResetAndDestroy();

    if (iSupportedArray)

        {

        iSupportedArray->ResetAndDestroy();

        }

    delete iSupportedArray;

    }

NONSHARABLE_CLASS(CItemFinderAsyncParser): public CActive

    {

public:

    static CItemFinderAsyncParser* NewL( CEikRichTextEditor* aEditor, TInt* aFirstVisible, TInt aMinDigitsToFind );

    void SetCallbackObserver( CItemFinder* aObserver ){ iObserver = aObserver; };

    ~CItemFinderAsyncParser();

    void RunL();

    void DoCancel();

    CFindItemEngine* iFIE;

    CArrayPtrFlat<CItemFinder::CFindItemExt>* iMarkedItems;

private:

    CItemFinderAsyncParser( CEikRichTextEditor* aEditor, TInt* aFirstVisible, TInt aMinDigitsToFind );

    CEikRichTextEditor* iEditor;

    TInt& iFirstVisible;

    CItemFinder* iObserver; // not owned

    TInt iMinDigitsToFind;

};

CItemFinderAsyncParser::CItemFinderAsyncParser( CEikRichTextEditor* aEditor, TInt* aFirstVisible, TInt aMinDigitsToFind )

    :CActive( CActive::EPriorityIdle ), iEditor( aEditor ), iFirstVisible( *aFirstVisible ), iMinDigitsToFind( aMinDigitsToFind )

    {

    CActiveScheduler::Add(this);

    iStatus = KRequestPending;

    SetActive();

    TRequestStatus* ptr = &iStatus;

    User::RequestComplete( ptr, KErrNone );// RunL will be called when everything with higher priority has completed

    }

CItemFinderAsyncParser* CItemFinderAsyncParser::NewL( CEikRichTextEditor* aEditor, TInt* aFirstVisible, TInt aMinDigitsToFind )

    {

    return new (ELeave) CItemFinderAsyncParser( aEditor, aFirstVisible, aMinDigitsToFind );

    }

CItemFinderAsyncParser::~CItemFinderAsyncParser()

    {

    Cancel(); // does nothing

    delete iFIE;

    if ( iMarkedItems )

        {

        iMarkedItems->ResetAndDestroy();

        }

    delete iMarkedItems;

    }

void CItemFinderAsyncParser::RunL()

    {

    TInt fullLength = Min( iEditor->TextLength(), 0xffff );

    const TDesC& text = iEditor->Text()->Read( 0, fullLength );

    TInt searchAll = CFindItemEngine::EFindItemSearchURLBin

        |CFindItemEngine::EFindItemSearchMailAddressBin

        |CFindItemEngine::EFindItemSearchPhoneNumberBin

        |CFindItemEngine::EFindItemSearchScheme;

    if ( !iFIE )

        {

        iFIE = CFindItemEngine::NewL( text, (CFindItemEngine::TFindItemSearchCase)searchAll, iMinDigitsToFind );

        }

    else

        {

        iFIE->DoNewSearchL( text, (CFindItemEngine::TFindItemSearchCase)searchAll, iMinDigitsToFind );

        }

    delete iMarkedItems;

    iMarkedItems = 0;

    iMarkedItems = new ( ELeave ) CArrayPtrFlat<CItemFinder::CFindItemExt>( 10 );

    iEditor->RefreshParsersL();

    if ( iObserver && iObserver->CallbackToExtObserver() == EFalse )

        {

        iEditor->SetCursorPosL( 0, EFalse ); // need to rollback in order to make sure that line will remain same

        if ( iFirstVisible > 0 )

            {

            iEditor->SetCursorPosL( iFirstVisible, EFalse ); // Magic, parsing forces screen to first item (?)

            }

        iObserver->NextItemOrScrollL( iFirstVisible ? CItemFinder::EInit : CItemFinder::EInitDown );

        }

    }

void CItemFinderAsyncParser::DoCancel()

    {

    }

EXPORT_C CItemFinder::CFindItemExt::~CFindItemExt()

		{

		if ( iItemDescriptor ) 

				delete iItemDescriptor;

		}

CItemFinder::~CItemFinder()

    {

    CRichText::DeactivateParser(this);   

    if ( iCurrentItemExt )

        {

        delete iCurrentItemExt;

        }    

    if ( iExternalLinks )

        {

        iExternalLinks->ResetAndDestroy();

        delete iExternalLinks;

        }

    if ( iAsyncParser )

        {

        delete iAsyncParser;

        }    

    if ( iSchemeResolver )

        {

        delete iSchemeResolver;

        }    

    }

    {}

void CItemFinder::ConstructL()

    {

    iMinDigitsToFind = KItemFinderMinDigitsToFind; // default

    iCurrentItemExt = new (ELeave) CFindItemExt();

    CRichText::ActivateParserL(this);

    iSchemeResolver = CSchemeResolver::NewL();

    iMinDigitsToFind = GetMinDigitsToFindL(); // variated.

    }

TInt CItemFinder::GetMinDigitsToFindL()

    {

    TInt err = KErrNone;

    CRepository* variation = CRepository::NewL( KCRUidCommonUi );

    TInt value;

    err = variation->Get( KCuiMinDigitsToFind, value );

    delete variation;

    if ( err != KErrNone )

        {

        value = KItemFinderMinDigitsToFind;

        }

    return value;

  }

EXPORT_C CItemFinder* CItemFinder::NewL( TInt aFindFlags )

    {

    CItemFinder* me = new (ELeave) CItemFinder( aFindFlags );

    CleanupStack::PushL( me );

    me->ConstructL();

    CleanupStack::Pop();

    return me;

    }

EXPORT_C TBool CItemFinder::NextItemOrScrollL( TFindDirection aDirection )

    {

    TBool allowScroll = ETrue;

    if ( !iEditor || !(*iEditor)  )

        {

        return EFalse;

        }

    if ( aDirection == EInit || aDirection == EInitUp || aDirection == EInitDown )

        {

        if ( aDirection == EInitUp )

            {

            iPreviousDirection = ENextUp;

            iCurrentStart = iCurrentEnd = (*iEditor)->TextLength() - 1;

            if ( iCurrentStart > 0 )

                {

                (*iEditor)->SetCursorPosL( iCurrentEnd, EFalse );

                if ( iAsyncParser && iAsyncParser->iMarkedItems && iAsyncParser->iMarkedItems->Count() > 0 )

                    // Check manually if the last item ends to last character in editor

                    // as CRichText can't handle this correctly

                    {

                    if ( iCurrentStart <= iAsyncParser->iMarkedItems->At( iAsyncParser->iMarkedItems->Count() - 1 )->iEnd )

                        {

                        ResolveAndSetItemTypeL( iAsyncParser->iMarkedItems->At( iAsyncParser->iMarkedItems->Count() - 1 )->iStart );

                        }

                    }

                }

            }

        else if ( aDirection == EInitDown )

            {

            iPreviousDirection = ENextDown;

            (*iEditor)->SetCursorPosL(0,EFalse);

            ResolveAndSetItemTypeL(0);

            }

        iFirstVisible = (*iEditor)->TextLayout()->FirstDocPosFullyInBand();

        (*iEditor)->TextView()->SetCursorVisibilityL( TCursor::EFCursorInvisible, TCursor::EFCursorInvisible );

        if ( iPreviousDirection == 0 )// just initialising

            {

            (*iEditor)->SetCursorPosL( iFirstVisible, EFalse );

            return EFalse;

            }

        // Search first tag on screen

        // and set the cursor but if none found, don't scroll

        allowScroll=EFalse;

        aDirection = iPreviousDirection;

        // check if we didn't scroll full display but only part of it

        TPoint dummy;

        if ( iCurrentStart != iCurrentEnd && (*iEditor)->TextLayout()->PosInBand( iCurrentStart, dummy ) )

            {

            (*iEditor)->SetCursorPosL( iCurrentStart, EFalse );

            if ( (*iEditor)->TextLayout()->PosInBand( iCurrentEnd, dummy ) )

                {

                // old selection should remain. basically this should be

                // the case only when tag was partly visible in previous screen

                (*iEditor)->SetSelectionL( iCurrentStart, iCurrentEnd );

                return ETrue;

                }

            }

        else if ( iPreviousDirection == ENextDown )

            { // to ensure correct scrolling of items

            (*iEditor)->SetCursorPosL( iFirstVisible, EFalse );

            }

        }

    TBool ret = EFalse;

    TInt nextItem = KErrNotFound;

    // Scroll cursor over tag or update page.

    iPreviousDirection = aDirection;

    TInt cursorPos = (*iEditor)->CursorPos();

    if ( aDirection == ENextDown )

        {

        if ( (*iEditor)->SelectionLength() )

            {

            cursorPos = iCurrentEnd;

            }

        if ( cursorPos == 0 )

            {

            ResolveAndSetItemTypeL( 0 );

            if ( iCurrentEnd != iCurrentStart )

                {

                TPoint pos;

                if ( ((*iEditor)->TextLayout()->PosInBand( iCurrentEnd, pos ) ) ) // tag does not continue over screen

                    {

                    NextItemOrScrollL( EInit ); // will set the selection

                    return ETrue;

                    }

                }

            }

        nextItem = (*iEditor)->RichText()->PositionOfNextTag( cursorPos, this );

        if ( nextItem != KErrNotFound )

            { // check whether the tag is on visible screen

            TPoint dummy;

            if ( !(*iEditor)->TextLayout()->PosInBand( nextItem, dummy ) )

                {

                nextItem = KErrNotFound;

                }

            }

        if ( allowScroll && nextItem == KErrNotFound )

            {

            (*iEditor)->MoveDisplayL( TCursorPosition::EFPageDown );

            if ( (*iEditor)->TextLayout()->FirstDocPosFullyInBand() != iFirstVisible )

                {// If keypress was effective.

                ret = ETrue;

                NextItemOrScrollL( EInit );

                }

            }

        }

    else

        {

        if ( (*iEditor)->SelectionLength() )

            {

            cursorPos = iCurrentStart;

            }

        nextItem = (*iEditor)->RichText()->PositionOfPrevTag( cursorPos, this );

        /* if nextItem is KErrNotFound can mean cursorPos is in the middel of an valid item.

         * so if cursorPos is in the middle of an vaild item, make sure that we adjust it to 

         * end of the item so that PositionOfPrevTag works fine

         */

        if( nextItem == KErrNotFound )

            {

            if ( cursorPos > 0 )

                {

                cursorPos -= 1;

                TInt temp = (*iEditor)->RichText()->PositionOfNextTag( cursorPos, this );

                if( temp != KErrNotFound )

                    {

                    cursorPos = temp;

                    }

                else

                    {

                    cursorPos = ( *iEditor )->TextLength();

                    }

                }

            nextItem = ( *iEditor )->RichText()->PositionOfPrevTag( cursorPos, this );

            }

        if ( nextItem >=0 && nextItem < iFirstVisible )

            {

            nextItem = KErrNotFound;

            }

        if ( allowScroll && nextItem == KErrNotFound )

            {

            (*iEditor)->MoveDisplayL( TCursorPosition::EFPageUp );

            TInt currPos = (*iEditor)->TextLayout()->FirstDocPosFullyInBand();

            if ( currPos != iFirstVisible )

                {// If keypress was effective.

                ret = ETrue;

                NextItemOrScrollL( EInit );

                }

            }

        }

    if ( nextItem != KErrNotFound || !allowScroll )

        {

        // Check !allowScroll for the case display was scrolled but previous item is still visible

        // and no new tag found, just make the selection visible again

        ret = ETrue;

        if ( nextItem != KErrNotFound )

            {

            iCurrentStart = nextItem;

            ResolveAndSetItemTypeL();

            }

        if ( iCurrentItemExt->iItemType != ENoneSelected )

            {

            TPoint pos;

            if ( ( !(*iEditor)->TextLayout()->PosInBand( iCurrentEnd ,pos ) ) ) // tag continues over screen

                {

                // lets check if we can scroll to show whole tag

                // if not, we'll just show what can be fitted to screen with hl

                (*iEditor)->TextLayout()->DocPosToXyPosL( iFirstVisible, pos );

                TRect lineRect;

                TPoint tagStart;

                (*iEditor)->TextLayout()->GetLineRect( pos.iY, lineRect );

                (*iEditor)->TextLayout()->DocPosToXyPosL( iCurrentStart, tagStart );

                if (!lineRect.Contains(tagStart) && allowScroll )

                    {

                    (*iEditor)->MoveDisplayL( TCursorPosition::EFPageDown );

                    while ( !(*iEditor)->TextLayout()->PosInBand( iCurrentStart, pos ) )

                        {

                        (*iEditor)->MoveDisplayL( TCursorPosition::EFLineUp );

                        }

                    NextItemOrScrollL(EInit);

                    }

                else if ( !lineRect.Contains( tagStart ) )

                    {

                    // we are not allowed to scroll, dont show highligh

                    iCurrentStart = iCurrentEnd = iFirstVisible;

                    ResetCurrentItem();

                    return ret;

                    }

                }

            else if ( nextItem == KErrNotFound )

                {

                // if the current end visible,and next item invisible, no select

                iCurrentStart = iCurrentEnd = iFirstVisible;

                ResetCurrentItem();

                return ret;

                }

            }

        if ( iCurrentStart < iCurrentEnd )

            {

            (*iEditor)->SetSelectionL( iCurrentStart, iCurrentEnd );

            }

        else

            {

            ResetCurrentItem(); // no item selected

            }

        }

    return ret;

    }

EXPORT_C void CItemFinder::SetFindModeL( TInt aFindFlags )

    {

    if ( iFlags != aFindFlags )

        {

        iFlags = aFindFlags;

        if ( iEditor && *iEditor )

            {

            User::LeaveIfError ( RefreshEditor() );

            }

        }

    if ( !aFindFlags && iEditor && *iEditor )

        {

        if (!iExternalObserver) // do not align if no control to scrolling

            {

            iCurrentEnd = iCurrentStart;

            iFirstVisible = (*iEditor)->TextLayout()->FirstDocPosFullyInBand();

            (*iEditor)->SetCursorPosL( iFirstVisible, EFalse );

            }

        ResetCurrentItem();

        }

    }

EXPORT_C void CItemFinder::SetEditor( CEikRichTextEditor** aEditor )

    {

    iEditor=aEditor;

    if ( aEditor && *aEditor && (*aEditor)->TextLength() )

        {

        TRAP_IGNORE( (*aEditor)->SetHighlightStyleL( EEikEdwinHighlightLink ) );

        if ( iAsyncParser )

            {

            // We are changing the editor used, strange.

            delete iAsyncParser;

            iAsyncParser = 0;

            }

        iMarkedArrayComplete = EFalse;

        TRAPD( err, iAsyncParser = CItemFinderAsyncParser::NewL( *iEditor, &iFirstVisible, iMinDigitsToFind ) ); // can't signal failure to client.

        if ( !err )

            {

            iAsyncParser->SetCallbackObserver( this );

            }

        }

    }

// From MParser

EXPORT_C TBool CItemFinder::ParseThisText(

    const CRichText& aTextObj,

    TBool /*aAllowBack*/,

    TInt aStartScan,

    TInt aScanLength,

    TInt& aStartTag,

    TInt& aTagLength )

    {

    TBool ret = EFalse;

    if ( iEditor && *iEditor && (*iEditor)->RichText() != &aTextObj )

        {

        return ret;

        }

    if ( !iAsyncParser || iAsyncParser->IsActive() || !iAsyncParser->iMarkedItems )

        {

        return ret; // Asynch parser not ready

        }

    TInt lastInRange = aStartScan + aScanLength;

    aStartTag = lastInRange;

    CFindItemEngine::SFoundItem item = { 0, 0 };

    HBufC* tag = 0;

    TInt engineFlags = EngineFlags();

    // Find (next) external item.

    CFindItemExt* externalItem = NULL;

    if ( iExternalLinks )

        {

        TInt externalIndex = 0;

        while ( externalIndex < iExternalLinks->Count() )

            {

            CFindItemExt* tmp = iExternalLinks->At( externalIndex );

            if ( tmp && ( tmp->iStart >= aStartScan ))

                {

                externalItem = tmp;

                switch( externalItem->iItemType )

                    {

                    case EUrlAddress:

                        item.iItemType = CFindItemEngine::EFindItemSearchURLBin;

                        break;

                    case EUriScheme:

                        item.iItemType = CFindItemEngine::EFindItemSearchScheme;

                        break;

                    default: // only EUrlAddress and EUriScheme supported