/*

* 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:

*

*/

#include <peninputcmd.h>

#include <coemain.h>

#include <txtrich.h>

#include <frmtlay.h>

#include <frmtview.h>

#include <eiksbfrm.h>

#include <aknappui.h>

#include <AknUtils.h>

#include <w32std.h>

#include <frmtlay.h>

#include <AknsDrawUtils.h>

#include <avkon.hrh>

#include <AknBidiTextUtils.h>

#include <bidivisual.h>

#include <AknFepGlobalEnums.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <tagmalayoutandsource.h>

#endif

#include "peninputlayoutcursor.h"

#include "peninputlayoutbubblectrl.h"

#include "peninputlayoutmultilineicf.h"

#include "peninputlayout.h"

#include "peninputlayoutmicfcustomdraw.h"

#include "peninputlayoutmicfnomatchesinline.h"

#include "AknPhoneNumberInlineTextSource.h"

#include "AknEdwinFormExtendedInterfaceProvider.h"

#include "AknCompositeInlineTextSource.h"

#include "peninputlayoutsmiley.h"

#include <gdi.h>

const TInt KParagraphSeperator = 0x2029;

const TInt KSecretUpdateTimer = 1000000; // 1s

const TInt KSecretInstantShowTimer = 100000; // 100ms

const TUint16 KSegment = 0x0020;

// separator between prompt text and normal text,

// should use localized character soon

const TUint16 KSeparator = 0x003a;

const TUint16 KSeparatorcn = 0xff1a;

_LIT(KLineSeparator, "\n");

const TInt KStar = '*';

const TInt KMaxMfneDataLen = 30;

// Message bubble position adjust

const TInt KMsgBubblePosAdjustValueX = 3;

const TInt KMsgBubblePosAdjustValueY = 2;

const TInt KPromptAdjustLen = 5;

EXPORT_C CFepLayoutMultiLineIcfEditor* CFepLayoutMultiLineIcfEditor::NewL(TRect aRect,

                                                              CFepUiLayout* aUiLayout,

                                                              TInt aControlId,

                                                              TInt aFontHeight,

                                                              TInt aMaxFontHeight,

                                                              const CFont* aFont)

    {

    CFepLayoutMultiLineIcfEditor* self = new (ELeave) CFepLayoutMultiLineIcfEditor(aRect, 

                                                                       aUiLayout, 

                                                                       aControlId);

    CleanupStack::PushL(self);

    self->BaseConstructL(aFontHeight, aMaxFontHeight, aFont);

    CleanupStack::Pop(self);

    return self;

    }

CFepLayoutMultiLineIcfEditor::CFepLayoutMultiLineIcfEditor(TRect aRect,

                                               CFepUiLayout* aUiLayout,

                                               TInt aControlId)

    :CFepUiBaseCtrl(aRect,aUiLayout,aControlId),

     iTextSelectionOn(ETrue),

     iTextInited(EFalse),

     iPntDownOnInline(EFalse),

     iPreInlineStartPos(0),

     iPreInlineEndPos(0),

     iPreAutoStartPos(0),

     iPreAutoEndPos(0),

     iPreTextSelStartPos(0),

     iPreTextSelEndPos(0),

     iSkinIdSet(EFalse),

     iNoMatchState(EFalse),

     iLineSeparator( EFalse ),

     iLeadingEdge(EFalse),

     iState(CFepLayoutMultiLineIcf::EIcfNormal)

    {

    SetControlType(ECtrlEditAreaBase);

    iCursorVisible = ETrue;

    iCursorSelVisible = ETrue;

#ifdef RD_TACTILE_FEEDBACK     

    //register the area for tactile feedback

    if(aUiLayout)

    	{

    	//Advanced Tactile feedback REQ417-47932

    	}

#endif //RD_TACTILE_FEEDBACK     

    }

CFepLayoutMultiLineIcfEditor::~CFepLayoutMultiLineIcfEditor()

    {

    delete iCustomDraw;

    delete iTextWrapper;

    delete iTextView; // text view

    delete iLayout; // text layout

    delete iRichText; // contained text object

    delete iCharFormatLayer; // char format layer

    delete iParaFormatLayer; // para format layer

    if (iWin)

        {

        iWin->Close();

        delete iWin;

        }

    //delete iContentCtrl;

    iOverlappedCtrlList.Close();

    iOverLapRects.Close();

	iOldMfneText.Close();

    if (iSecretTextTimer)

        iSecretTextTimer->Cancel();

    delete iSecretTextTimer;

    delete iInitPromptText;

    delete iPromptText;

    delete iMfneIcfData;

    //delete iCtrl;

    if(iFormExtendedInterfaceProvider)

        {

        delete iFormExtendedInterfaceProvider;

        iFormExtendedInterfaceProvider = NULL;

        }

    delete iSmileyManager;

    }

void CFepLayoutMultiLineIcfEditor::InitTextLayoutL()

    {

	iParaFormatLayer=CParaFormatLayer::NewL();

	iCharFormatLayer=CCharFormatLayer::NewL();

	iRichText = CRichText::NewL(iParaFormatLayer, iCharFormatLayer);

	iViewRect = Rect();

	iLayout = CTextLayout::NewL(iRichText, iViewRect.Width());

    //iLayout->SetAmountToFormat( CTextLayout::EFFormatBand );

    //TInt x = 0;

    //iLayout->SetFontHeightIncreaseFactor(10);

    //iLayout->SetMinimumLineDescent( x );

    //CContentControl* ctrl = new(ELeave) CContentControl;

    //iWndControl = ctrl;    

    //ctrl->ConstructL();    

    iWin = new(ELeave) RWindow(iCoeEnv->WsSession());

    iWin->Construct(iCoeEnv->RootWin(),reinterpret_cast<TInt>(this));

    //iWin = ctrl->GetWindow();

    //TBool b = iWin->IsRedrawStoreEnabled();

    iWin->EnableRedrawStore(EFalse);

    iWin->SetVisible(EFalse);

    // another method to avoid crash caused by HandleRedrawEvent 

    // when (screen resolution changed)

    //iCtrl = new (ELeave) CCoeControl;

    //iCtrl->SetContainerWindowL(*iWin);    

    //iWin->Construct(iCoeEnv->RootWin(),reinterpret_cast<TInt>(iCtrl));

    //ctrl->SetExtent(iViewRect.iTl, iViewRect.Size());

	iTextView = CTextView::NewL(iLayout, 

	                            iViewRect,

                        		BitmapDevice(),

                        		iCoeEnv->ScreenDevice(),

                        		iWin,

                        		&iCoeEnv->RootWin(),

                        		&iCoeEnv->WsSession()); 

    iTextView->SetCursorVisibilityL(TCursor::EFCursorInvisible, TCursor::EFCursorInvisible);

    if (!iCustomDraw)

        {

        iCustomDraw = new (ELeave) CFepLayoutMIcfCustomDraw(this);

        iLayout->SetCustomDraw(iCustomDraw);

        }

    if ( !iTextWrapper )

        {

        iTextWrapper = new (ELeave) CFepLayoutMIcfCustomWrap();

        iLayout->SetCustomWrap( iTextWrapper );

        }

    //SetTextMarginL(30);

    iTextView->DisableFlickerFreeRedraw();

    iTextView->FormatTextL(); 

    iMfneIcfData = HBufC::NewL( KMaxMfneDataLen );

    }

void CFepLayoutMultiLineIcfEditor::SetTextAlignmentL(TInt aAlignment, TInt aLanguage)

    {

    CParaFormat* paraFormat = CParaFormat::NewL();

    CleanupStack::PushL(paraFormat);

    TParaFormatMask paraFormatMask;

    paraFormat->iLanguage = ELangEnglish;

    if ( aAlignment == EAknEditorAlignNone )

        {

        // fix: Prompt text in ICF moves on dimmed VITU-T window after rotating screen.

        aAlignment = iAlignment;

        }

    switch (aAlignment)

        {

        case EAknEditorAlignLeft: 

            paraFormat->iHorizontalAlignment = CParaFormat::EAbsoluteLeftAlign;

            iTextAlign = CGraphicsContext::ELeft;

            break;

        case EAknEditorAlignRight:

            paraFormat->iHorizontalAlignment = CParaFormat::EAbsoluteRightAlign;

            iTextAlign = CGraphicsContext::ERight;

            break;

        case EAknEditorAlignCenter:

            paraFormat->iHorizontalAlignment = CParaFormat::ECenterAlign;

            iTextAlign = CGraphicsContext::ECenter;

            break;

        case EAknEditorAlignBidi:

            {

            paraFormat->iHorizontalAlignment = CParaFormat::ELeftAlign;

            paraFormat->iLanguage = aLanguage;

            iTextAlign = CGraphicsContext::ELeft;

            break;

            }

        default:

            paraFormat->iHorizontalAlignment = CParaFormat::ELeftAlign;

            iTextAlign = CGraphicsContext::ELeft;

            break;

        }

    paraFormatMask.SetAttrib(EAttParaLanguage);

    paraFormatMask.SetAttrib(EAttAlignment);

    iRichText->ApplyParaFormatL(paraFormat,

                                paraFormatMask,

                                0,

                                iPromptTextLen);

    iRichText->ApplyParaFormatL(paraFormat,

                                paraFormatMask,

                                iPromptTextLen,

                                iRichText->DocumentLength() - iPromptTextLen);

	iTextView->FormatTextL();                            

    CleanupStack::PopAndDestroy(paraFormat);

    iAlignment = aAlignment;

    }

void CFepLayoutMultiLineIcfEditor::BaseConstructL(TInt aFontHeight, 

                                            TInt aMaxFontHeight, 

                                            const CFont* aFont)

    {

    CFepUiBaseCtrl::BaseConstructL();

    iCoeEnv = CCoeEnv::Static();

    //iMaxFontHeight = aMaxFontHeight;

    //iFontHeight = aFontHeight;

    //iFont = aFont;

    InitTextLayoutL();

    iInsertionPoint = UiLayout()->CreateCursor();

    iInsertionPoint->SetOwner(this);

    SetFontL(aFontHeight, aMaxFontHeight, aFont);

    iSecretTextTimer = CPeriodic::NewL(CActive::EPriorityStandard);

    SetAutoCompleteTextColor(KRgbGray);

    //EnableTextSelection(EFalse);

    iSmileyManager = CPeninputSmileyManager::NewL();

    }

void CFepLayoutMultiLineIcfEditor::SetTextColorL(const TRgb aColor)

    {

    iCharFormatMask.ClearAttrib( EAttFontUnderline );

    iTextColor = aColor;

    iCharFormat.iFontPresentation.iTextColor = aColor;

    iCharFormatMask.SetAttrib(EAttColor);

    iRichText->ApplyCharFormatL(iCharFormat, iCharFormatMask, 0, iRichText->DocumentLength());

    //iRichText->SetInsertCharFormatL(iCharFormat, iCharFormatMask, iRichText->DocumentLength());    

    }

void CFepLayoutMultiLineIcfEditor::SetTextSelColorL(const TRgb aColor)

    {

    iCharFormatMask.ClearAttrib( EAttFontUnderline );

    iTextSelColor = aColor;

    iCharFormat.iFontPresentation.iHighlightColor = aColor;

    iCharFormatMask.SetAttrib(EAttFontHighlightColor);

    iRichText->ApplyCharFormatL(iCharFormat, iCharFormatMask, 0, iRichText->DocumentLength());

    //iRichText->SetInsertCharFormatL(iCharFormat, iCharFormatMask, iRichText->DocumentLength());    

    }

void CFepLayoutMultiLineIcfEditor::SetAutoCompleteTextColor(const TRgb aColor)

    {

    iTextAutoColor = aColor;

    }

TBool CFepLayoutMultiLineIcfEditor::IsFocused()

    {

    return iHasFocus;

    }

void CFepLayoutMultiLineIcfEditor::DeletePromptTextL()

    {

    // delete original prompt text

    if (iPromptTextLen > 0)

        {

        iRichText->DeleteL(0, iPromptTextLen);

        iTextView->HandleInsertDeleteL(TCursorSelection(0, 0),

                                       iPromptTextLen);

        }

    }

void CFepLayoutMultiLineIcfEditor::RecalculatePosByNewPromptTextL(const TDesC& aNewPromptText)

    {

    // recalculate cursor pos

    AdjustSelectionL(TCursorSelection(iTextView->Selection().iCursorPos + aNewPromptText.Length() - iPromptTextLen,

                     iTextView->Selection().iAnchorPos + aNewPromptText.Length() - iPromptTextLen));

    // set new cursor position    

    iPreInlineStartPos += (aNewPromptText.Length() - iPromptTextLen);

    iPreInlineEndPos += (aNewPromptText.Length() - iPromptTextLen);

    iPreAutoStartPos += (aNewPromptText.Length() - iPromptTextLen);

    iPreAutoEndPos += (aNewPromptText.Length() - iPromptTextLen);

    iPreTextSelStartPos += (aNewPromptText.Length() - iPromptTextLen);

    iPreTextSelEndPos += (aNewPromptText.Length() - iPromptTextLen);

    }

const HBufC* CFepLayoutMultiLineIcfEditor::PromptText()

	{

	return iPromptText;	

	}

void CFepLayoutMultiLineIcfEditor::SetPromptTextL(const TDesC& aPromptText, TBool aCleanContent)

    {

    if ( aCleanContent )

    	{

    	//clean all the content (include prompt text) on the ICF

        TInt length = iRichText->DocumentLength();

        iRichText->DeleteL( 0,  length);

        iTextView->HandleInsertDeleteL(TCursorSelection(0, 0), length);

    	iTextView->SetSelectionL( TCursorSelection(0, 0) );

    	iCursorSel = TCursorSelection(0, 0);

        iNoMatchState = EFalse;

    	}

    else 

        {

        /*if ( ( ( !iInitPromptText && aPromptText.Length() == 0 ) )|| 

            ( iInitPromptText && *iInitPromptText == aPromptText && 

            iPromptText && TextWidth(*iPromptText) <= iViewRect.Width()) )

    	    {

    	    //prompt text has not been change then need not to be reset

    	    //but iLineSeparator may be changed, need reset prompt text

    	    return;

            }*/

        //prompt text need to be reset and not clean the content

        iRichText->DeleteL( 0,  iPromptTextLen );

        iTextView->HandleInsertDeleteL(TCursorSelection(0, 0), iPromptTextLen );

        }

    TBool bPromptTextChange = EFalse;

    if ( !iInitPromptText || *iInitPromptText != aPromptText )

        {

        //prompt text has been changed

        delete iInitPromptText;

        iInitPromptText = NULL;

        if ( aPromptText.Length() > 0 )

            {

        	iInitPromptText = HBufC::NewL( aPromptText.Length() );

        	iInitPromptText->Des().Copy( aPromptText );

            }

        bPromptTextChange = ETrue;

        }

    delete iPromptText;

    iPromptText = NULL;

    if (aPromptText == KNullDesC)

        {

        RecalculatePosByNewPromptTextL(KNullDesC);

        iPromptTextLen = 0;

        if( bPromptTextChange )

        	{

        	UpdateArea( Rect(), EFalse );

        	} 

        return;

        }

    // The extra length is separators between prompt text and normal text

    TInt prompttextLen;

    if ( !iLineSeparator )

        {

        iLineSeparator = ( TBidiText::TextDirectionality( aPromptText ) == TBidiText:: ERightToLeft );

        }

    iLineSeparator ? 

               prompttextLen = aPromptText.Length() + TBidiLogicalToVisual::KMinCharAvailable + 3 :

               prompttextLen = aPromptText.Length() + TBidiLogicalToVisual::KMinCharAvailable + 2;

    iPromptText = HBufC::NewL(prompttextLen);

    TPtr text = iPromptText->Des();

    TBuf<1> ptr0;

    ptr0.Append( KEllipsis );

    TPtrC ptr1(&KSegment, 1);

    TPtrC ptr2(&KSeparator, 1);

    TInt separatorLen = TextWidth(ptr1) + TextWidth(ptr2) + TextWidth(ptr0);

    TInt textWidth = TextWidth(aPromptText) + separatorLen;

    TBool ret = EFalse;

    if (textWidth >= iViewRect.Width() )

        {

        ret = ETrue;

        AknBidiTextUtils::ConvertToVisualAndClip(aPromptText,

                                                 text,

                                                 *iFont,

                                                 iViewRect.Width() - separatorLen - KPromptAdjustLen,

                                                 iViewRect.Width() - separatorLen - KPromptAdjustLen,

                                                 AknBidiTextUtils::EImplicit,

                                                 0xFFFF);

        TInt charNums = iFont->TextCount( text, iViewRect.Width() - separatorLen );

        text = aPromptText.Left( charNums );

        }

    else

        {

        text.Copy(aPromptText);

        }

	for ( ;(text.Length() > 0 && text.LocateReverse(KSegment) == text.Length()-1 ); )

	    {

		text.Delete( text.Length()-1, 1 );

	    }

    if ((text.LocateReverse(KSeparator) != text.Length() - 1) && 

        (text.LocateReverse(KSeparatorcn) != text.Length() - 1))

        {

        // if sent prompt text already include separator, then no need to 

        // append it again

        if ( ret )

            {

            text.Append( ptr0 );

            }

        text.Append(ptr2);

        }

    else if ( ret )

        {

        text.Insert( text.Length()-1, ptr0 );

        }        

    text.Append(ptr1); // segment between prompt text and official text

    textWidth = TextWidth(text);

    iRichText->InsertL(0, text);

    iTextView->HandleInsertDeleteL(TCursorSelection(0, text.Length()),

                                   0);

    if (iLineSeparator)

        {

    	iRichText->InsertL(text.Length(), CEditableText::EParagraphDelimiter);

    	iTextView->HandleInsertDeleteL(TCursorSelection(text.Length(), text.Length()+1), 0);

    	text.Append(KLineSeparator);

        }

    RecalculatePosByNewPromptTextL(text);

    iPromptTextLen = text.Length();

    // apply format to prompt text and normal text

    SetPromptTextFormatL(iPromptTextLen);

    CalcPromptTextRectL();

    if( bPromptTextChange )

    	{

    	UpdateArea(Rect(),EFalse);

    	} 

    }

void CFepLayoutMultiLineIcfEditor::AdjustIcfDataForPromptText(TFepInputContextFieldData& aData)

    {

    if (iPromptTextLen == 0)

        return;

    aData.iCurSel.iCursorPos += iPromptTextLen;

    aData.iCurSel.iAnchorPos += iPromptTextLen;

    aData.iStartPos += iPromptTextLen;

    }

void CFepLayoutMultiLineIcfEditor::SetMfneTextL(const TFepInputContextFieldData& aData)

    {

    TFepInputContextFieldData icfdata = aData;

    TPtr ptr = iMfneIcfData->Des();

    switch (icfdata.iCmd)

        {

        case EPeninputICFInitial:

            {