/*

* Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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 FILES

// System includes

#include <calslbs.h>

#include <eikenv.h>

#include <eikedwin.h>

#include <e32std.h>

#include <PtiDefs.h>

#include <txtrich.h>

#include <bautils.h>

#include <webkit.rsg>

#include <PUAcodes.hrh>

#include <FeatMgr.h>

#include <baclipb.h>

#include <aknedsts.h>

// User includes

#include "nw_fbox_WmlFormattedEditor.h" 

// CONSTANTS

static const TInt KWmlDefaultTextColor = 215; ///< black (plain text)

static const TInt KWmlFormattedInputErrorColor = 35; ///< TEMP : should be clarified!

const TInt KFullFormattingUpperThreshold=2000;

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

// C++ default constructor can NOT contain any code, that

// might leave.

//

CWmlFormattedEditor::CWmlFormattedEditor( TBool aIsSecret ) : CEikRichTextEditor()

        , iDefaultColour( AKN_LAF_COLOR( KWmlDefaultTextColor ) )

        , iErrorColour( AKN_LAF_COLOR( KWmlFormattedInputErrorColor ) )

        , iPosAtEnd(EFalse)

        , iEventKeyEntered(EFalse)

        , iDuplicateEvent(EFalse)

        , iVkbState(NULL)

    {

    SetAknEditorPermittedCaseModes( EAknEditorAllCaseModes );

    UpdateInputModeState(EAknEditorTextInputMode, EAknEditorAllInputModes);

    TUint flags( EAknEditorFlagDefault |

                       EAknEditorFlagUseSCTNumericCharmap |

                       EAknEditorFlagNoT9 | EAknEditorFlagMTAutoOverwrite );

    // NOTE: Use of "variant" indicator will be removed in near term - code will be changed

    // allowing simpler conditional as EAknEditorFlagLatinInputModesOnly will be allowed

    // in European and Apac builds.

    EVariantFlag variant = AknLayoutUtils::Variant();

    if (aIsSecret && variant == EApacVariant)

        {

        UpdateFlagsState( flags | EAknEditorFlagLatinInputModesOnly );

        SetAknEditorCase( EAknEditorLowerCase );

        }

    else 

        {

        UpdateFlagsState( flags );

        SetAknEditorCase( EAknEditorTextCase );

        }

    SetBorder(TGulBorder::EDeepSunkenWithOutline);

    iWmlEdNavigation = EWmlEditorNavigateRight ;

    iPenEnabled = AknLayoutUtils::PenEnabled();

    }

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

// CWmlFormattedEditor::InitializeL

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

//

void CWmlFormattedEditor::InitializeL

( CWmlFormatHandler* aHandler, TBool aSecret, TWmlMode aMode )

    {

    iHandler = aHandler;

    iSecret = aSecret;

    if ( iSecret && !iHandler ) // T9 must be disabled in password editor

        {

        iPassword = HBufC::NewL( 1 );

        }

    iMode = aMode;

    iPrevMode = EWmlModeNone;

    /*lint -e{40} Undeclared identifier 'KFeatureIdJapanese'*/

     if (!FeatureManager::FeatureSupported(KFeatureIdJapanese))

        {

        iMode = EWmlModeNone; 

        }

    }

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

// CWmlFormattedEditor::SetDefaultColour

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

//

void CWmlFormattedEditor::SetDefaultColour( TRgb aDefaultColour )

    {

    iDefaultColour = aDefaultColour;

    }

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

// CWmlFormattedEditor::SetErrorColour

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

//

void CWmlFormattedEditor::SetErrorColour( TRgb aErrorColour )

    {

    iErrorColour = aErrorColour;

    }

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

// CWmlFormattedEditor::EnableT9

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

//

void CWmlFormattedEditor::EnableT9( TBool aEnable, TBool aIsSecret )

    {

    iT9 = aEnable;

    TUint flags = iT9 ? EAknEditorFlagDefault |

            EAknEditorFlagUseSCTNumericCharmap | EAknEditorFlagMTAutoOverwrite

            : EAknEditorFlagDefault |

            EAknEditorFlagUseSCTNumericCharmap |

            EAknEditorFlagNoT9 | EAknEditorFlagMTAutoOverwrite;

    EVariantFlag variant = AknLayoutUtils::Variant();

    if (aIsSecret && variant == EApacVariant)

        {

        UpdateFlagsState( flags | EAknEditorFlagLatinInputModesOnly );

        }

    else 

        {

        UpdateFlagsState( flags );

        }

    }

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

// CWmlFormattedEditor::IsSecret

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

//

TBool CWmlFormattedEditor::IsSecret() const

    {

    return iSecret;

    }

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

// CWmlFormattedEditor::ReadableTextL

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

//

HBufC* CWmlFormattedEditor::ReadableTextL() const

    {

    HBufC* result = ReadableTextLC();

    CleanupStack::Pop(); // result

    return result;

    }

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

// CWmlFormattedEditor::ReadableTextLC

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

//

HBufC* CWmlFormattedEditor::ReadableTextLC() const

    {

    HBufC* result = NULL;

    if ( iHandler ) // formatted?

        {

        result = iHandler->TextLC(); // zeroterminated

        }

    else

        {

        if ( iPassword ) // secret?

            {

            /*lint --e{1058} nitializing a non-const reference */

            // make a zeroterminated copy

            result = HBufC::NewLC( iPassword->Length() + 1);

            result->Des() = *iPassword;

            result->Des().ZeroTerminate();

            }

        else

            {

            // make a zeroterminated copy

            result = HBufC::NewLC( TextLength() + 1 );

            TPtr ptr = result->Des();

            if (TextLength() > 0)

                {

                GetText( ptr );

                }

            result->Des().ZeroTerminate();

            }

        }

    return result;

    }

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

// CWmlFormattedEditor::MarkInvalidCharsL

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

//

void CWmlFormattedEditor::MarkInvalidCharsL()

    {

    if ( iHandler )

        {

        // make character format

        TCharFormat charFormat;

        charFormat.iFontPresentation.iTextColor = iDefaultColour;

        TCharFormatMask charFormatMask;

        charFormatMask.SetAttrib( EAttColor );

        // unmark all, by colouring to default

        RichText()->ApplyCharFormatL

        ( charFormat, charFormatMask, 0, iText->DocumentLength() );

        charFormat.iFontPresentation.iTextColor = iErrorColour;

        const CArrayFixFlat<TInt>* errors = iHandler->ValidateTextLC();

        TInt endIndex = errors->Count() - 1;

        for ( ; endIndex > -1; ) // loop through the errors

            {

            // find a block of errors

            TInt startIndex = endIndex - 1;

            TInt endPos = errors->At( endIndex );

            for ( ;

                  startIndex > -1 &&

                  endPos - errors->At( startIndex ) ==

                  endIndex - startIndex;

                  startIndex-- )

                { // find the lower border of error block

                }

            TInt blockLength = endIndex - startIndex;

            RichText()->ApplyCharFormatL   // colour that block

            ( charFormat,

              charFormatMask,

              errors->At( startIndex + 1 ),

              blockLength );

            endIndex = startIndex;

            }

        CleanupStack::PopAndDestroy(); // errors

        }

	UpdateColour(iDefaultColour);

    NotifyNewFormatL();  // redraws editor

    }

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

// CWmlFormattedEditor::UpdateColour(TRgb aDefaultColour)

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

//

void CWmlFormattedEditor::UpdateColour(TRgb aDefaultColour)

    {

        // make character format

        TCharFormat charFormat;

        charFormat.iFontPresentation.iTextColor = aDefaultColour;

        TCharFormatMask charFormatMask;

        charFormatMask.SetAttrib( EAttColor );

    	RichText()->ApplyCharFormatL(charFormat, charFormatMask, CursorPos(), 0);

        }

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

// CWmlFormattedEditor::FreePassword

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

//

void CWmlFormattedEditor::FreePassword()

    {

    delete iPassword;

    iPassword = NULL;

    }

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

// CWmlFormattedEditor<Editor>::T9Enabled

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

//

TBool CWmlFormattedEditor::T9Enabled() const

    {

	return iT9;

    }

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

// CWmlFormattedEditor<Editor>::SetiCursorPos

// Note: when switching modes to and from T9 this will

// prevent duplication of characters when switch from T9 to

// multi-tap input.

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

//

void CWmlFormattedEditor::SetiCursorPos() 

    {

    iCursorPos = CursorPos();

    }

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

// CWmlFormattedEditor<Editor>::ResetFlagEventKeyEntered

// Resets flag used to indicate input via EVENTKEY event handling.

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

//

void CWmlFormattedEditor::ResetFlagEventKeyEntered()

    {

    iEventKeyEntered = EFalse;

    }

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

// CWmlFormattedEditor<Editor>::IsEventKeyEntered

// Returns iEventKeyEntered, a flag used to indicate when

// key data received via EVENTKEY event handling.

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

//

TBool CWmlFormattedEditor::IsEventKeyEntered()

    {

    return iEventKeyEntered;

    }

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

// CWmlFormattedEditor::SpecialHandlingPasswordL

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

//

void CWmlFormattedEditor::SpecialHandlingPasswordL()

    {

    TInt cursorPos( CursorPos() );

    TInt length( CursorPos() - iCursorPos +1);

    if (length <= 0)

        {

        length = 1;

        }

    TInt firstEmpty( TextLength() );

    if (iHandler && iHandler->NumberOfStatic() > 0)

        {

        firstEmpty = iHandler->FirstEmpty();

        }

    if ( (iFirstEmpty <= firstEmpty ) )

        {   // insert character into storage place

        if ( IsEventKeyEntered() )

            {

            return; // already added by iEditor->OfferKey

            }

        HBufC* newText = HBufC::NewLC( length );

        TPtr ptr = newText->Des();

        Text()->Extract( ptr, iCursorPos, length );

        if ( iHandler )

            {

            iHandler->InsertL( iCursorPos, *newText );

            iWmlEdNavigation = EWmlEditorNavigateRight;

            }

        else

            {                    

            if ( iPassword )

                {

                TInt newLength( iPassword->Length() + length );

                if ( newLength > iPassword->Des().MaxLength() )

                    {

                    iPassword = iPassword->ReAllocL( newLength + 1);

                    }

                iPassword->Des().Insert( iCursorPos, *newText );                               

                iWmlEdNavigation = EWmlEditorNavigateRight;

                }

            }

        CleanupStack::PopAndDestroy();  // newText

        }

    else

        {  // remove character from storage place

        if ( iHandler )

            {

            iHandler->Delete( cursorPos, 1 );  // cursorPos already is actual cursor - 1 

            SetCursorPosL( 0 );

            iText->Reset();

            CEikRichTextEditor::SetTextL( iHandler->TextLC() );

            CleanupStack::PopAndDestroy(); // for return value of iHandler->TextLC

            SetCursorPosL( cursorPos );

            }

        else

            {

            if ( iPassword && cursorPos >= 0 )

                {

                iPassword->Des().Delete( cursorPos, 1 );

                }

            }

        }

    }

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

// CWmlFormattedEditor::SpecialStaticHandlingL

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

//

void CWmlFormattedEditor::SpecialStaticHandlingL()

    {

	TInt  pos = CursorPos();

    TBool adjustPosFlag = EFalse; // if static char in proximity, adjust cursor to get input character.

    // There is no special handling if a DELETE (clear/backspace) has been done.

    // We now distinguish between a "NavigateLeft" and a "NavigateDelete".

    if ( iWmlEdNavigation == EWmlEditorNavigateDelete )

        {

        // reset

        iWmlEdNavigation = EWmlEditorNavigateRight;

        return;

        }

    // This is compensation code for Avkon taking control of cursor movement when looping from last

    // char position to first position and Avkon does not send browser input an indication that this is

    // happening.

    if (iCursorPos > pos)

        {

        iCursorPos = pos;

        if (pos > 0)

            {

            iCursorPos = pos - 1;

            }

        }

    // If an input box with static text, prep the text to use

    // asking if we are doing an insertion

    if ( !IsEventKeyEntered() && iHandler && iHandler->NumberOfStatic())

        { 

        HBufC* text = NULL;

        TInt length = pos - iCursorPos;

        if (length > 0)

            {

            text = HBufC::NewLC( length );

            }

        if ( iWmlEdNavigation == EWmlEditorNavigateLeft )

            {

            iCursorPos = pos;     // adjust now

            if (iCursorPos > 0)

                {

                --iCursorPos;

                }

            iWmlEdNavigation = EWmlEditorNavigateRight;

            }

        // When a static char is reached during input, the iCursorPos and CursorPos() values indicate the

        // correct NEXT location, but edwin seems to ignore where it SHOULD be and the cursor remains on the

        // static character location.  This code is to compensate in part for this with respect to inserting

        // the new character into the saved input area.  There is still an issue however

        // with edwin / commitinput() re-setting the cursor position to an improper location - that is - it's

        // not ahead of the newly inserted character, but behind it.

        if ( (pos - 1 >= 0) && iHandler->IsPosStatic( pos - 1 ))

            {

            --pos;

            adjustPosFlag = ETrue;

            }

        if ( text )  // with whatever info was obtained, store it into iHandler

            {

            TPtr ptr = text->Des();

            Text()->Extract( ptr, iCursorPos, length );

            if (adjustPosFlag)

                {

                iCursorPos = pos;

                }

            iHandler->InsertL( iCursorPos, *text );

            ++ iNumberOfCharsInStaticInputBox;

            CleanupStack::PopAndDestroy();		// text

            }

        iCursorPos = pos;

        }

    }

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

// CWmlFormattedEditor::SpecialCharHandlingL

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

//

void CWmlFormattedEditor::SpecialCharHandlingL()

    {

	if (IsSecret() || ( iHandler && iHandler->NumberOfStatic()) )

        {

        if ( IsSecret() )

            {

            SpecialHandlingPasswordL();

            }

        // if secret (that is, type password) -and- static text in format do additional handling

        // otherwise if static text in format only (input field is -not- a password type)

        // do the additional handling

        if (iHandler && iHandler->NumberOfStatic())

            {

            SpecialStaticHandlingL();

            }

        UpdateStateL( iWmlEdNavigation, ETrue, ETrue );

        }

    else

        {

        if (iHandler)

            {

            HBufC* text; 

            text = GetTextInHBufL();

            if ( text )

                {  // add the new char entry to locally held storage.  If there was a shift in input mode

                   // from char to numeric, it may have been possible for a char to slip in before the new

                   // input mode may have taken effect in Avkon - so for right now, remove it.

                TInt pos = CursorPos();

                TWmlFormatChar format = iHandler->GetFormat( pos );

                if ( TWmlFormatChar::EWmlNumericCase == format.ForcedCase() )

                    {

                    // really want to delete the inadvertantly added char and add the number for "scancode"

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

                    }

                CleanupStack::PushL( text );

                //iHandler->SetTextL( *text, EFalse );  // removes static stuff and stores chars in iHandler.iDynamic

                // For VKB we want all chars to show so we shut off validation.  

                //   Validation will still happen when you try to exit the input box.

                iHandler->SetTextL( *text, iPenEnabled );  // removes static stuff and stores chars in iHandler.iDynamic

                CleanupStack::PopAndDestroy();		// text

                }

            else

                {

                iHandler->SetTextL( KNullDesC(), ETrue );

                }

            }

        }

    TInt tempPos = CursorPos();

    UpdateEditingParameters( tempPos );

    if ( IsEventKeyEntered() && !iInputFormatProcess )

        {

        ResetFlagEventKeyEntered();