/*******************************************************************************

 * Copyright (c) 2005, 2010 Nokia Corporation and/or its subsidiary(-ies).

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     Nokia Corporation - S60 implementation

 *******************************************************************************/

#include <EIKCOCTL.rsg>

#include <AknUtils.h>

#include <eikedwin.h>

#include <AknNumEdwin.h>

#include <eikfpne.h>

#include "swttext.h"

#include "swtcontrolhelper.h"

#include "swtscrollbar.h"

#include "swtedwin.h"

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <tagma_internal.h>

#endif

static const TText KDefaultSecretChar = '*';

#define KInputModesRequiringFeedbackWithSingleChar (EAknEditorTextInputMode | EAknEditorKatakanaInputMode | EAknEditorFullWidthTextInputMode | EAknEditorFullWidthKatakanaInputMode | EAknEditorHiraganaKanjiInputMode | EAknEditorHiraganaInputMode | EAknEditorHalfWidthTextInputMode)

#define KInputModesRequiringFeedbackWithString (EAknEditorHiraganaInputMode | EAknEditorHiraganaKanjiInputMode)

const TInt KPasswordCharTimeout = 700000; // 700 msecs

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

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

// CSwtText::CPasswordText::CPasswordText

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

//

inline CSwtText::CPasswordText::CPasswordText(

    const CParaFormatLayer* aParaLayer, const CCharFormatLayer* aCharLayer,

    CEikEdwin* aEdwin, TBool aPswdEnable)

        : CGlobalText(aParaLayer, aCharLayer)

        , iEchoChar(0), iEditor(aEdwin), iClearCharPos(-1), iPswdEnable(aPswdEnable)

{

}

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

// CSwtText::CPasswordText::~CPasswordText

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

//

CSwtText::CPasswordText::~CPasswordText()

{

    delete iTimer;

    delete iClearText;

}

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

// CSwtText::CPasswordText::ConstructL

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

//

inline void CSwtText::CPasswordText::ConstructL()

{

    CGlobalText::ConstructL(ESegmentedStorage, EDefaultTextGranularity);

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

    iClearText = HBufC::NewL(CEditableText::EDefaultTextGranularity);

}

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

// CSwtText::CPasswordText::NewL

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

//

CSwtText::CPasswordText* CSwtText::CPasswordText::NewL(

    const CParaFormatLayer* aParaLayer,

    const CCharFormatLayer* aCharLayer, CEikEdwin* aEdwin, TBool aPswdEnable)

{

    CPasswordText* self = new(ELeave) CPasswordText(

        aParaLayer, aCharLayer, aEdwin, aPswdEnable);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

}

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

// CSwtText::CPasswordText::SaveClearTextL

// We save our clear text. We reallocate if not enough memory.

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

//

void CSwtText::CPasswordText::SaveClearTextL(TInt aPos, const TDesC& aBuf)

{

    ASSERT(iClearText);

    TPtr ptr(iClearText->Des());

    TInt totalLength = ptr.Length() + aBuf.Length();

    //

    if (totalLength > ptr.MaxLength())

    {

        iClearText = iClearText->ReAllocL(totalLength);

        ptr.Set(iClearText->Des());

    }

    ptr.Insert(aPos,aBuf);

}

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

// CSwtText::CPasswordText::Reset

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

//

void CSwtText::CPasswordText::Reset()

{

    if (iPswdEnable)

    {

        if (iTimer->IsActive())

        { //commit any previous character before deleting or else we

            // may crash in the timer callback when trying to replace

            // an uncommited but already deleted char

            TRAP_IGNORE(DoTimerCallbackL(EFalse));

        }

    }

    // clear local (hidden) copy

    TPtr ptr = iClearText->Des();

    ptr.SetLength(0);

    CGlobalText::Reset();

}

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

// CSwtText::CPasswordText::InsertL

// Insert a single character. First we save the character in the clear text by

// calling SaveClearTextL(). Then if the character is a paragraph delimiter

// insert a space.Otherwise if we are in alpha mode insert the clear

// character and start the timer. Otherwise insert the asterisks.

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

//

void CSwtText::CPasswordText::InsertL(TInt aPos, const TChar& aChar)

{

    TBuf<1> buf;

    buf.Append(aChar);

    SaveClearTextL(aPos, buf);

    if (iPswdEnable)

    {

        if (aChar == CEditableText::EParagraphDelimiter)

        {

            CGlobalText::InsertL(aPos, ' ');

        }

        else if (iEditor->AknEditorCurrentInputMode() &

                 KInputModesRequiringFeedbackWithSingleChar)

        {

            if (iTimer->IsActive() && iClearCharPos != aPos)

            { //commit any previous character in a different position

                DoTimerCallbackL(ETrue);

            }

            else

            { //or restart the timer if the char is in the same

                //position (multi-tap looping)

                iTimer->Cancel();

            }

            CGlobalText::InsertL(aPos, aChar);

            iClearCharPos = aPos;

            iTimer->Start(KPasswordCharTimeout, KPasswordCharTimeout,

                          TCallBack(TimerCallback, this));

        }

        else

        {

            CGlobalText::InsertL(aPos, iEchoChar);

        }

    }

    else

    {

        if (iEchoChar)

        {

            CGlobalText::InsertL(aPos, iEchoChar);

        }

        else

        {

            CGlobalText::InsertL(aPos, aChar);

        }

    }

}

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

// CSwtText::CPasswordText::InsertL

// Insert one or more characters. If inserting only one character rely

// on InsertL() accepting only one char. Otherwise, save the clear text by

// calling SaveClearTextL(). Then for every character either insert an asterisk

// or a space if the character is a space delimiter. Note: this method is

// called at start-up so it makes no sense to show a temporary clear character.

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

//

void CSwtText::CPasswordText::InsertL(TInt aPos,const TDesC& aBuf)

{

    if (iPswdEnable)

    {

        if (aBuf.Length() == 1)

        {

            CSwtText::CPasswordText::InsertL(aPos, aBuf[0]);

        }

        else if (aBuf.Length() > 1 && (iEditor->AknEditorCurrentInputMode() &

                                       KInputModesRequiringFeedbackWithString))

        {

            // When writing in kanji or hiragana input mode, the characters are

            // entered in sequences. Insert the sequence char by char so that

            // the user will see the last character temporarily for feedback.

            for (TInt i = 0; i < aBuf.Length(); i++)

            {

                CSwtText::CPasswordText::InsertL(aPos + i, aBuf[i]);

            }

        }

        else

        {

            SaveClearTextL(aPos, aBuf);

            for (TInt i = 0; i < aBuf.Length(); i++)

            {

                if (aBuf[i] == CEditableText::EParagraphDelimiter)

                {

                    CGlobalText::InsertL(aPos + i, ' ');

                }

                else

                {

                    CGlobalText::InsertL(aPos + i, iEchoChar);

                }

            }

        }

    }

    else

    {

        if (iEchoChar)

        {

            SaveClearTextL(aPos, aBuf);

            for (TInt i = 0; i < aBuf.Length(); i++)

            {

                if (aBuf[i] == CEditableText::EParagraphDelimiter)

                {

                    CGlobalText::InsertL(aPos + i, ' ');

                }

                else

                {

                    CGlobalText::InsertL(aPos + i, iEchoChar);

                }

            }

        }

        else

        {

            for (TInt i = 0; i < aBuf.Length(); i++)

            {

                CSwtText::CPasswordText::InsertL(aPos + i, aBuf[i]);

            }

        }

    }

}

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

// CSwtText::CPasswordText::SetEchoCharL

// Support Changin all characters to masked character when we set the

// SetEchoCharater

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

//

void CSwtText::CPasswordText::SetEchoCharL()

{

    TInt length = iClearText->Des().Length();

    if (length > 0)

    {

        CGlobalText::DeleteL(0,length);

        if (iEchoChar)

        {

            for (int i = 0; i < length; i++)

            {

                CGlobalText::InsertL(i, iEchoChar);

            }

        }

        else

        {

            CGlobalText::InsertL(0 , iClearText->Des());

        }

        iEditor->NotifyNewFormatL();

    }

}

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

// CSwtText::CPasswordText::PasteFromStoreL

// Support for pasting in the Text with EchoCharacter. The normal insertion

// mechanism is not used in the paste operation, so it must be handled separately

// here. This is an overriden method that stores the pasted chars to the local

// store and puts masked chars (*) to the visible store (in super class).

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

//

TInt CSwtText::CPasswordText::PasteFromStoreL(const CStreamStore& aStore,

        const CStreamDictionary& aDictionary,

        TInt aPos)

{

    // 1. Paste clipboard text (to visible text)

    TInt numCharsPasted = CGlobalText::PasteFromStoreL(aStore, aDictionary, aPos);

    // 2. Insert the pasted text to the local clear text store

    TPtr content(SwtControlHelper::GetClipboardTextContentLC());

    TPtrC ptr = content.Ptr();

    SaveClearTextL(aPos, ptr);

    if (iEchoChar)

    {

        // 3. Mask the visible text

        for (int i = 0; i < numCharsPasted; i++)

        {

            TPtrC charToProcess = Read(aPos+i, 1);

            TChar replaceChar   = iEchoChar;

            if (charToProcess[0] == CEditableText::EParagraphDelimiter)

            {

                replaceChar = ' ';

            }

            CGlobalText::DeleteL(aPos+i,1);

            CGlobalText::InsertL(aPos+i, replaceChar);

        }

    }

    if (content.Ptr())

    {

        CleanupStack::PopAndDestroy();

    }

    return numCharsPasted;

}

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

// CSwtText::CPasswordText::CopyToStoreL

// Support for copying Text with EchoCharacter constraint. The normal mechanism

// is not used in the copy operation, so it must be handled separately here.

// This is an overriden method that stores the copied chars to the local store

// and puts masked chars (*) to the visible store (in super class).

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

//

void CSwtText::CPasswordText::CopyToStoreL(CStreamStore& aStore,

        CStreamDictionary& aDictionary,

        TInt aPos,

        TInt aLength) const

{

    if (!iEchoChar)

    {

        // this allow to copy in single line text without

        // Echo Character set

        CGlobalText::CopyToStoreL(aStore, aDictionary,

                                  aPos, aLength);

    }

    else

    {

        // here we should handle the situation that it shouldn't

        // delete already existing clipboard contents.

    }

}

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

// CSwtText::CPasswordText::Delete

// Delete one or more chars, this makes sure our clear text stays

// in sync.

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

//

TBool CSwtText::CPasswordText::DeleteL(TInt aPos,TInt aLength)

{

    if (iPswdEnable)

    {

        if (iTimer->IsActive())

        { //commit any previous character before deleting or else we

            // may crash in the timer callback when trying to replace

            // an uncommited but already deleted char

            DoTimerCallbackL(EFalse);

        }

    }

    TPtr ptr = iClearText->Des();

    ptr.Delete(aPos, aLength);

    return CGlobalText::DeleteL(aPos, aLength);

}

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

// CSwtText::CPasswordText::Extract

// This method is called by edwin when returning text to the user via

// a GetText() call. We make sure we return the clear text instead of the

// masking used by edwin.

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

//

void CSwtText::CPasswordText::Extract(TDes& aBuf,TInt aPos) const

{

    if (iPswdEnable || iEchoChar)

    {

        aBuf.SetLength(0);

        aBuf.Append(iClearText->Mid(aPos));

    }

    else

    {

        CGlobalText::Extract(aBuf, aPos);

    }

}

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

// CSwtText::CPasswordText::Extract

// This method is called by edwin when returning text to the user via

// a GetText() call. We make sure we return the clear text instead of the

// masking used by edwin.

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

//

void CSwtText::CPasswordText::Extract(TDes& aBuf,

                                      TInt aPos,

                                      TInt aLength) const

{

    if (iPswdEnable || iEchoChar)

    {

        aBuf.SetLength(0);

        aBuf.Append(iClearText->Mid(aPos, aLength));

    }

    else

    {

        CGlobalText::Extract(aBuf, aPos, aLength);

    }

}

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

// CSwtText::CPasswordText::TimerCallbackL

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

//

TInt CSwtText::CPasswordText::TimerCallback(TAny* aThis)

{

    CPasswordText* self = STATIC_CAST(CPasswordText*, aThis);

    ASSERT(self);

    TRAPD(err, self->DoTimerCallbackL(ETrue));

    return err;

}

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

// CSwtText::CPasswordText::DoTimerCallbackL

// It is time to remove the temporary clear character. Do a delete at

// iClearCharPos and then insert an asterisk at this position. Then we need to

// call something that signals the edwin to update its characters,

// NotifyNewFormatL() seems to do the job. Note: this is only needed when inse-

// rting a char from the special char table or when holding a key down so that

// a number is inserted even if in alpha input mode. Otherwise you do not notice

// the differece as edwin update its text anyway when commiting a fep transaction

// after a timeout that seems just about longer than our timeout.

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

//

void CSwtText::CPasswordText::DoTimerCallbackL(TBool aNotifyFormat)

{

    iTimer->Cancel();

    ASSERT(iClearCharPos != -1 && (DocumentLength() > iClearCharPos));

    // here checking iEchochar is for null character in iEchoChar that does mask

    // the characters so we dont need to insert or delete.

    if (iClearCharPos != -1 && (DocumentLength() > iClearCharPos) && iEchoChar)

    {

        CGlobalText::DeleteL(iClearCharPos,1);

        CGlobalText::InsertL(iClearCharPos, iEchoChar);

        if (aNotifyFormat && iEditor->TextView())

        {

            iEditor->NotifyNewFormatL();

        }

        iEditor->DrawDeferred();

    }

}

// CSwtText::~CSwtText

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

//

CSwtText::~CSwtText()

{

    //iiBufferToVerify.Close();

}

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

// CSwtText::ConstructL

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

//

void CSwtText::ConstructL()

{

    CSwtTextBase::ConstructL();

    TUint aknFlags = 0;

    // Compute edwin flags from our style

    TUint flags = CEikEdwin::ESegmentedStorage | CEikEdwin::ELineCursor

                  | CEikEdwin::EInclusiveSizeFixed | CEikEdwin::ENoAutoSelection

                  | CEikEdwin::EResizable  | CEikEdwin::EWidthInPixels;

    if (!(iStyle & KSwtStyleWrap))

    {

        flags |= CEikEdwin::ENoWrap;

    }

    if (iStyle & KSwtStyleReadOnly)

    {

        flags |= CEikEdwin::EReadOnly;

    }

    // Single/multi - line

    TInt lineCount;

    if (iStyle & KSwtStyleSingle)

    {

        flags |= CEikEdwin::ENoLineOrParaBreaks | CEikEdwin::ENoWrap;

        lineCount = 1;

    }

    else

    {

        lineCount = 0;

    }

    // Construct the editor

    CSwtEdwin* editor = new(ELeave) CSwtEdwin;

    SetEditor(editor);

    editor->ConstructL(flags, 0, ETextLimit, lineCount);

    editor->SetContainerWindowL(*this);

    if (iStyle & KSwtStyleSingle)

    {

        CParaFormatLayer* paraLayer = iEikonEnv->SystemSingleLineParaFormatLayerL();

        CCharFormatLayer* charLayer = iEikonEnv->SystemCharFormatLayerL();

        CPasswordText* passwordText = CPasswordText::NewL(

                                          paraLayer, charLayer, editor, iStyle & KSwtStylePassword);

        delete editor->Text();

        // Ownership of passwordText is transferred

        editor->SetDocumentContentL(*passwordText, CEikEdwin::EUseText);

    }

    editor->CreateTextViewL();

    editor->SetDimmed(IsDimmed());