/*

* Copyright (c) 1997-1999 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:

*

*/

#include <s32mem.h>

#include <s32file.h>

#include <s32std.h>

#include <fldinfo.h>

#include <basched.h>

#include <baclipb.h>

#include <txtglobl.h>

#include <eikdef.h>

#include <fldbase.h>

#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <txtrich.h>

#else

#include <txtrich.h>

#include <txtclipboard.h>

#include <uikon/eikdefmacros.h>

#include <uikon/eikenvinterface.h> 

#endif

#include <txtfmlyr.h>

#include <txtfrmat.h>

#include <frmtview.h>

#include <barsread.h>

#include <coecobs.h>

#include <coemain.h>

#include <eikedwin.pan>

#include <eikpanic.h>

#include <uikon.hrh>

#include <gulutil.h>

#include <eikenv.h>

#include <eikedwin.h>

#include <eikcoctl.rsg>

#include <avkon.rsg>

#include <gulcolor.h>

#include <eikirfty.h>

#include "LAFEDWIN.H"

#include <lafmain.h>

#include <uiklaf/private/lafenv.h>

#include <aknedsts.h>

#include <frmtlay.h>

#include <tagma.h>

#include <eiksvdef.h>

#include <AknUtils.h>

#include <fepipext.h>

#include <aknedformaccessor.h>

#include <coemop.h>

#include <AknSettingCache.h>

#include <aknenv.h>

#include <AknDef.h>

#include <AknsDrawUtils.h>

#include "aknedwincustomdrawprivate.h"

#include "aknedwindrawingmodifier.h"

#include "FromCursorModifierUtils.h"

#include <AknTasHook.h>

#include <FormCursorModifier.h>

#include <formcursormodifierint.h>

#include <biditext.h>

#include <bidivisual.h>

#include <AknBidiTextUtils.h>

#include "aknedwinphysicshandler.h"

#include "AknEdwinFormExtendedInterfaceProvider.h"

#include "AknNoMatchesIndicatorInlineTextSource.h"

#include "AknPhoneNumberInlineTextSource.h"

#include "AknRichTextPhoneNumberInlineTextSource.h"

#include "AknCompositeInlineTextSource.h"

#include <featmgr.h>

#include <aknconsts.h>

#include <AknPictographInterface.h>

#include <aknappui.h>

#include <jplangutil.h>

#include <AknSgcc.h>

#include <AknLayoutFont.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <aknextendedinputcapabilities.h>

#include <PUAcodes.hrh>

#include <AknFepInternalCRKeys.h> // KAknFepHashKeySelection

#include <eikrted.h>

#include <NumberGroupingCRKeys.h>

#include <aknpointereventsuppressor.h>

#include <aknnotedialog.h>

#include <AknFepGlobalEnums.h>

#include "smileymanager.h"

#include "smileycustomwrap.h"

#include <touchfeedback.h>

// declare function

void ReadSpecialCharFromSCTL( TPtr& ptr, TInt sctResourceId );

void ReadSCTHeadPane( TResourceReader& aReader );

GLDEF_C void Panic(TEikEdwinPanic aPanic)

    {

    _LIT(KPanicCat,"EIKON-EDWIN");

    User::Panic(KPanicCat,aPanic);

    }

// For neutral character protection 

enum 

    {

    EEikEdwinLeftToRightMark = 0x200E,

    EEikEdwinRightToLeftMark = 0x200F 

    };

_LIT(KEikEdwinLeftToRightMark, "\x200E" );  // LRM

_LIT(KEikEdwinRightToLeftMark, "\x200F" );  // RLM

// Used by neutral protection code to extract small chunks of the editor at a time 

// while searching for strong characters.

const TInt KLengthAtATime(3);

// Constants for controlling the switching between band and full document formatting

const TInt KFullFormattingUpperThreshold=2000;      // Default initial value

const TInt KPartialFormattingLowerThreshold=1900;   // Default initial value

// This should be consistent with the difference between the two default limits:

const TInt KFormattingThresholdGap=100; 

// This should be significantly bigger than KFormattingThresholdGap (and certainly > 0):

const TInt KMinimumPartialFormattingLength=400; 

const TInt KMinimumFullFormattingLength=KMinimumPartialFormattingLength+KFormattingThresholdGap;

// Unicode sign for S60 "enter" symbol

const TInt KDownwardsArrowWithTipLeftwards  = 0x21B2;

const TInt KDownwardsArrowWithTipRightwards = 0x21B3;

// Unicode for euro sign

const TInt KEuroSign = 0x20AC;

const TInt KSegmSize = 1024;

const TInt KNormalAnimPlayTimes = 2;

const TInt KInfiniteAnimPlayTimes = 0x7ffff;

const TInt KAdditionalPixels = 0x400;

const TInt KFullFormatLengthForSmiley = 5000;

const TInt KContentThreshold = 8;

const TInt KNmericSCTLimit( 256 );

const TInt KTInt16Length( sizeof( TInt16 ) );

const TInt KTInt32Length( sizeof( TInt32 ) );

const TInt KTUint32Length( sizeof( TUint32 ) );

//

// class CEikEdwin::CUndoBuffer

//

class CEikEdwin::CUndoBuffer : public CBase

    {

public:

    static CUndoBuffer* NewL();

    ~CUndoBuffer();

    CBufStore& Store() const;

    CStreamDictionary& Dictionary() const;

    TCursorSelection NewText() const;

    void SetNewText(const TCursorSelection& aSelection);

    TInt OldCursorPos() const;

    void SetOldCursorPos(TInt aPos);

private:

    void ConstructL();

private:

    CBufStore* iStore;

    CStreamDictionary* iDictionary;

    TCursorSelection iNewText;

    TInt iOldCursorPos;

    };

CEikEdwin::CUndoBuffer* CEikEdwin::CUndoBuffer::NewL()

    { // static

    CUndoBuffer* self=new(ELeave) CUndoBuffer;

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();  // self

    return self;

    }

CEikEdwin::CUndoBuffer::~CUndoBuffer()

    {

    delete iStore;

    delete iDictionary;

    }

void CEikEdwin::CUndoBuffer::ConstructL()

    {

    iStore=CBufStore::NewL(512);

    iDictionary=CStreamDictionary::NewL();

    }

CBufStore& CEikEdwin::CUndoBuffer::Store() const

    {return *iStore;}

CStreamDictionary& CEikEdwin::CUndoBuffer::Dictionary() const

    {return *iDictionary;}

TCursorSelection CEikEdwin::CUndoBuffer::NewText() const

    {return iNewText;}

void CEikEdwin::CUndoBuffer::SetNewText(const TCursorSelection& aSelection)

    {iNewText=aSelection;}

TInt CEikEdwin::CUndoBuffer::OldCursorPos() const

    {return iOldCursorPos;}

void CEikEdwin::CUndoBuffer::SetOldCursorPos(TInt aPos)

    {iOldCursorPos=aPos;}

void CEikEdwin::CEikEdwinExtension::TAknEdwinPictographDrawer::DrawPictographArea()

    {

    }

//

// class CEikEdwinFepSupport

//

NONSHARABLE_CLASS(CEikEdwinFepSupport) : public CBase, public MCoeFepAwareTextEditor, public MCoeFepAwareTextEditor_Extension1, public TCoeInputCapabilities::MCoeFepSpecificExtensions

    {

    friend class CEikEdwin;

public:

    // The length of text window

    const static TInt KMaxSegmentLength = 10000;

    // The threshold for text window position change

    const static TInt KSegmentUpdateTrigger = 100;

    static CEikEdwinFepSupport* New(CEikEdwin& aEdwin);

    virtual ~CEikEdwinFepSupport();

    TBool IsHandledByFepL(TPointerEvent::TType aType, TUint aModifiers, TInt aDocumentPosition);

    /**

    * Set the input capabilities in the edwin fep support object. A copy of the input capabilities

    * is maintained in and owned by the fep support; 

    *

    * @param aInputCapabilities     Reference to desired input capabilities object

    */

    void SetInputCapabilitiesL(const TCoeInputCapabilities& aInputCapabilities);

    const TCoeInputCapabilities* InputCapabilities() const;

    void ConstructStateHolder();

    // from MCoeFepAwareTextEditor_Extension1

    void SetStateTransferingOwnershipL(CState* aState, TUid aTypeSafetyUid);

    CState* State(TUid aTypeSafetyUid); // this function does *not* transfer ownership

    // New functions for Touch Input sync performance improvement. A sliding window method is used 

    // here to show only part of text of editor to Touch Input, so the text sync between Touch input and 

    // editor can be faster.

    /**

     * To update start position of text window according to cursor position. The cursor position has to

     * be in the visible text window.

     */

    void UpdateDocPosOffsetL( TInt aCursorPos );

    /**

     * To check if FEP wants to get information of whole text, not the text window.

     */

    TBool FepRequireWholeTextData() const;

private:

    enum TPointerState

        {

        EPointerIsUp,

        EPointerIsDownStartingInsideInlineText,

        EPointerIsDownStartingOutsideInlineText

        };

    struct SPointerEventInInlineText

        {

        inline SPointerEventInInlineText(TPointerEvent::TType aType, TUint aModifiers, TInt aPositionInInlineText) :iType(aType), iModifiers(aModifiers), iPositionInInlineText(aPositionInInlineText) {}

        TPointerEvent::TType iType;

        TUint iModifiers;

        TInt iPositionInInlineText;

        };

private:

    CEikEdwinFepSupport(CEikEdwin& aEdwin);

    void UpdateTextViewAfterChangeInInlineTextL(TBool aParagraphContainingStartPositionOfInlineTextHasChangedFormat,TInt aNumberOfCharactersSuccessfullyDeleted,TInt aNumberOfCharactersSuccessfullyInserted,TInt aError);

    void UpdateTextViewAfterChangeInInlineTextL(TBool aParagraphContainingStartPositionOfInlineTextHasChangedFormat,TInt aNumberOfCharactersSuccessfullyDeleted,TInt aNumberOfCharactersSuccessfullyInserted,TInt aError,TInt aSelectionAnchorPosition);

    void ResetInternalState();

    // from MCoeFepAwareTextEditor

    virtual void StartFepInlineEditL(const TDesC& aInitialInlineText, TInt aPositionOfInsertionPointInInlineText, TBool aCursorVisibility, const MFormCustomDraw* aCustomDraw, MFepInlineTextFormatRetriever& aInlineTextFormatRetriever, MFepPointerEventHandlerDuringInlineEdit& aPointerEventHandlerDuringInlineEdit);

    virtual void UpdateFepInlineTextL(const TDesC& aNewInlineText, TInt aPositionOfInsertionPointInInlineText);

    virtual void SetInlineEditingCursorVisibilityL(TBool aCursorVisibility);

    virtual void CancelFepInlineEdit();

    virtual TInt DocumentLengthForFep() const;

    virtual TInt DocumentMaximumLengthForFep() const;

    virtual void SetCursorSelectionForFepL(const TCursorSelection& aCursorSelection);

    virtual void GetCursorSelectionForFep(TCursorSelection& aCursorSelection) const;

    virtual void GetEditorContentForFep(TDes& aEditorContent, TInt aDocumentPosition, TInt aLengthToRetrieve) const; // must cope with aDocumentPosition being outside the range 0 to DocumentLengthForFep()

    virtual void GetFormatForFep(TCharFormat& aFormat, TInt aDocumentPosition) const;

    virtual void GetScreenCoordinatesForFepL(TPoint& aLeftSideOfBaseLine, TInt& aHeight, TInt& aAscent, TInt aDocumentPosition) const;

    virtual void DoCommitFepInlineEditL();

    virtual MCoeFepAwareTextEditor_Extension1* Extension1(TBool& aSetToTrue);

    virtual void MCoeFepAwareTextEditor_Reserved_2();

    // from MCoeFepAwareTextEditor_Extension1

//  virtual void SetStateTransferingOwnershipL(CState* aState, TUid aTypeSafetyUid);

//  virtual CState* State(TUid aTypeSafetyUid);

    virtual void StartFepInlineEditL(TBool& aSetToTrue, const TCursorSelection& aCursorSelection, const TDesC& aInitialInlineText, TInt aPositionOfInsertionPointInInlineText, TBool aCursorVisibility, const MFormCustomDraw* aCustomDraw, MFepInlineTextFormatRetriever& aInlineTextFormatRetriever, MFepPointerEventHandlerDuringInlineEdit& aPointerEventHandlerDuringInlineEdit);

    virtual void SetCursorType(TBool& aSetToTrue, const TTextCursor& aTextCursor);

    virtual void MCoeFepAwareTextEditor_Extension1_Reserved_3();

    virtual void MCoeFepAwareTextEditor_Extension1_Reserved_4();

    // from TCoeInputCapabilities::MCoeFepSpecificExtensions

    virtual TBool IsValidCharacter(TInt aChar);

    virtual void MCoeFepSpecificExtensions_Reserved_1();

    virtual void MCoeFepSpecificExtensions_Reserved_2();

private:

    CEikEdwin& iEdwin;

    TCursorSelection iOriginalSelection;

    TInt iPositionOfInsertionPointInDocument;

    TInt iPositionOfInlineTextInDocument;

    TInt iLengthOfInlineText;

public: 

    const MFormCustomDraw* iOldCustomDraw; // does not own anything

    MTouchFeedback* iFeedback;

    TBool iSelectionIsCancel;

    TInt iMoveThumbFeedbackNeeded;

    // record start position of text window

	TInt iDocPosOffset;

private:    

    MFepPointerEventHandlerDuringInlineEdit* iPointerEventHandlerDuringInlineEdit; // does not own anything

    SPointerEventInInlineText iLastPointerEventInInlineText;

    TPointerState iPointerState;

    TCoeInputCapabilities* iInputCapabilities;

    CState* iState;

    TUid iStateTypeSafetyUid;

    TInt iCharsDeleted;

    TInt iCharsInserted;

    TBool iShowCursor;

    };

CEikEdwinFepSupport* CEikEdwinFepSupport::New(CEikEdwin& aEdwin)

    {

    return new CEikEdwinFepSupport(aEdwin);

    }

CEikEdwinFepSupport::~CEikEdwinFepSupport()

    {

    delete iInputCapabilities;

    delete iState;

    }

TBool CEikEdwinFepSupport::IsHandledByFepL(TPointerEvent::TType aType,TUint aModifiers,TInt aDocumentPosition)

    {

    if (iPositionOfInlineTextInDocument>=0)

        {

        __ASSERT_DEBUG((iOriginalSelection.iCursorPos>=0) && (iOriginalSelection.iAnchorPos>=0) && (iPositionOfInsertionPointInDocument>=0) && (iPositionOfInlineTextInDocument>=0) && (iLengthOfInlineText>=0) && (iPointerEventHandlerDuringInlineEdit!=NULL),Panic(EEikPanicBadInlineEditingState1));

        const TInt positionOfFirstCharacterInDocumentAfterInlineText=iPositionOfInlineTextInDocument+iLengthOfInlineText;

        switch (aType)

            {

        case TPointerEvent::EDrag:

        case TPointerEvent::EButton1Up:

            if (iPointerState!=EPointerIsUp)

                {

                break;

                }

            // fall through (only will do this if no preceding TPointerEvent::EButton1Down occurred, either initially or since the previous TPointerEvent::EButton1Up event)

        case TPointerEvent::EButton1Down:

            if ((aDocumentPosition>=iPositionOfInlineTextInDocument) && (aDocumentPosition<=positionOfFirstCharacterInDocumentAfterInlineText))

                {

                iPointerState=EPointerIsDownStartingInsideInlineText;

                }

            else

                {

                iPointerState=EPointerIsDownStartingOutsideInlineText;

                }

            break;

#if defined(__GCC32__)

        default:

            break;

#endif

            }

        const TBool pointerIsDownStartingInsideInlineText=(iPointerState==EPointerIsDownStartingInsideInlineText);

        if (aType==TPointerEvent::EButton1Up)

            {

            iPointerState=EPointerIsUp;

            }

        if (pointerIsDownStartingInsideInlineText)

            {

            if (aDocumentPosition<iPositionOfInlineTextInDocument)

                {

                aDocumentPosition=iPositionOfInlineTextInDocument;

                }

            if (aDocumentPosition>positionOfFirstCharacterInDocumentAfterInlineText)

                {

                aDocumentPosition=positionOfFirstCharacterInDocumentAfterInlineText;

                }

            const TInt positionInInlineText=aDocumentPosition-iPositionOfInlineTextInDocument;

            if ((aType!=iLastPointerEventInInlineText.iType) || (aModifiers!=iLastPointerEventInInlineText.iModifiers) || (positionInInlineText!=iLastPointerEventInInlineText.iPositionInInlineText))

                {

                iLastPointerEventInInlineText.iType=aType;

                iLastPointerEventInInlineText.iModifiers=aModifiers;

                iLastPointerEventInInlineText.iPositionInInlineText=positionInInlineText;

                iPointerEventHandlerDuringInlineEdit->HandlePointerEventInInlineTextL(aType,aModifiers,positionInInlineText);

                }

            return ETrue;

            }

        }

#if defined(_DEBUG)

    else

        {

        __ASSERT_DEBUG((iOriginalSelection.iCursorPos<0) && (iOriginalSelection.iAnchorPos<0) && (iPositionOfInsertionPointInDocument<0) && (iPositionOfInlineTextInDocument<0) && (iLengthOfInlineText<0) && (iOldCustomDraw==NULL) && (iPointerEventHandlerDuringInlineEdit==NULL),Panic(EEikPanicBadInlineEditingState2));

        }

#endif

    return EFalse;

    }

// This method treats the input capabilities slightly oddly in order to avoid re-allocation of Heap

void CEikEdwinFepSupport::SetInputCapabilitiesL(const TCoeInputCapabilities& aInputCapabilities)

    {

    if (iInputCapabilities==NULL)

        {

        iInputCapabilities=new(ELeave) TCoeInputCapabilities(aInputCapabilities); // copy constructor

        }

    else

        {

        *iInputCapabilities=aInputCapabilities;  // Structure copy. OK for T class.

        }

    }

const TCoeInputCapabilities* CEikEdwinFepSupport::InputCapabilities() const

    {

    return iInputCapabilities;

    }

void CEikEdwinFepSupport::ConstructStateHolder()

    {

    iState = new CAknEdwinState(STATIC_CAST(MEikCcpuEditor*, &iEdwin));

    if (iState)

        static_cast<CAknEdwinState*>(iState)->SetObjectProvider(&iEdwin);

    }

#pragma warning (disable: 4355) // warning disabled: "'this' : used in base member initializer list"

CEikEdwinFepSupport::CEikEdwinFepSupport(CEikEdwin& aEdwin)

    :iEdwin(aEdwin),

     iOriginalSelection(-1,-1),

     iPositionOfInsertionPointInDocument(-1),

     iPositionOfInlineTextInDocument(-1),

     iLengthOfInlineText(-1),

     iOldCustomDraw(NULL),

     iFeedback(MTouchFeedback::Instance()),

     iSelectionIsCancel(EFalse),

     iMoveThumbFeedbackNeeded(EFalse),

     iPointerEventHandlerDuringInlineEdit(NULL),

     iLastPointerEventInInlineText((TPointerEvent::TType)-1,0,0),

     iPointerState(EPointerIsUp),

     iInputCapabilities(NULL)

    {

    __DECLARE_NAME(_S("CEikEdwinFepSupport"));

    }

#pragma warning (default: 4355) // warning disabled: "assignment within conditional expression"

void CEikEdwinFepSupport::UpdateTextViewAfterChangeInInlineTextL(TBool aParagraphContainingStartPositionOfInlineTextHasChangedFormat,TInt aNumberOfCharactersSuccessfullyDeleted,TInt aNumberOfCharactersSuccessfullyInserted,TInt aError)

    {

    UpdateTextViewAfterChangeInInlineTextL(aParagraphContainingStartPositionOfInlineTextHasChangedFormat,aNumberOfCharactersSuccessfullyDeleted,aNumberOfCharactersSuccessfullyInserted,aError,iPositionOfInsertionPointInDocument);

    }

void CEikEdwinFepSupport::UpdateTextViewAfterChangeInInlineTextL(TBool aParagraphContainingStartPositionOfInlineTextHasChangedFormat,TInt aNumberOfCharactersSuccessfullyDeleted,TInt aNumberOfCharactersSuccessfullyInserted,TInt aError,TInt aSelectionAnchorPosition)

    {

    TCursorSelection select( iPositionOfInsertionPointInDocument, aSelectionAnchorPosition );

    iEdwin.iTextView->SetPendingSelection( select );    

    select.iAnchorPos = iPositionOfInlineTextInDocument;

    select.iCursorPos = select.iAnchorPos + aNumberOfCharactersSuccessfullyInserted;

    if ( iEdwin.iEdwinExtension->iSmiley )

        { 

        TInt textChange( aNumberOfCharactersSuccessfullyInserted - aNumberOfCharactersSuccessfullyDeleted );

        if ( textChange == 0 )

            {

            if ( iCharsDeleted < aNumberOfCharactersSuccessfullyDeleted )

                {

                iEdwin.iEdwinExtension->iSmiley->HandleDeleteL( iPositionOfInlineTextInDocument,

                        aNumberOfCharactersSuccessfullyDeleted - iCharsDeleted );

                iCharsDeleted = aNumberOfCharactersSuccessfullyDeleted;

                }

            if ( iCharsInserted < aNumberOfCharactersSuccessfullyInserted )

                {

                iEdwin.iEdwinExtension->iSmiley->HandleInsertL( 

                        iPositionOfInlineTextInDocument, 

                        ( aNumberOfCharactersSuccessfullyInserted - iCharsInserted ) );

                iCharsInserted = aNumberOfCharactersSuccessfullyInserted;

                }

            }

        else

            {

            if ( textChange > 0 )

                {

                iEdwin.iEdwinExtension->iSmiley->HandleInsertL( 

                    select.iAnchorPos + aNumberOfCharactersSuccessfullyDeleted, 

                    textChange );

                }

            else if ( textChange < 0 )

                {

                iEdwin.iEdwinExtension->iSmiley->HandleDeleteL( aSelectionAnchorPosition,

                    textChange * -1 );

                }

            }

        }

    iEdwin.iTextView->HandleInsertDeleteL( select, aNumberOfCharactersSuccessfullyDeleted,

        aParagraphContainingStartPositionOfInlineTextHasChangedFormat );

    User::LeaveIfError(aError);

    iEdwin.SetScrollBarsL();

    iEdwin.DoReportEventL(MCoeControlObserver::EEventStateChanged);

    if (aParagraphContainingStartPositionOfInlineTextHasChangedFormat)

        {

        iEdwin.ReportEdwinEventL(MEikEdwinObserver::EEventFormatChanged);

        }    

    }

void CEikEdwinFepSupport::ResetInternalState()

    {

    iOriginalSelection.SetSelection(-1,-1);

    iPositionOfInsertionPointInDocument=-1;

    iPositionOfInlineTextInDocument=-1;

    iLengthOfInlineText=-1;

    iOldCustomDraw=NULL;

    iPointerEventHandlerDuringInlineEdit=NULL;