/*

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

*

*/

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <uikon/eikdefmacros.h>

#endif

#include <eikseced.h>

#include <barsread.h>

#include <eikenv.h>

#include <eikpanic.h>

#include <e32keys.h>

#include <aknedsts.h>

#include <gulcolor.h>

#include <AknUtils.h>

#include <avkon.rsg>

#include <aknenv.h>

#include <aknappui.h>

#include <aknsoundsystem.h>

#include <AknsFrameBackgroundControlContext.h>

#include <AknsDrawUtils.h>

#include <PUAcodes.hrh>

#include <AknTasHook.h>

#include <AknTextDecorationMetrics.h>

#include <AknLayoutFont.h>

#include <aknextendedinputcapabilities.h>

#include <touchfeedback.h>

#define KSecretChar '*'

#define KSecretCharAsString "*"

#define KWait 1000000

_LIT(KSecretCharString, "*******************************");

#ifdef RD_UI_TRANSITION_EFFECTS_PHASE2

#include <gfxtranseffect/gfxtranseffect.h>

#include <akntransitionutils.h>

#include <avkondomainpskeys.h>

#include <e32property.h>

// Helper class that monitor redirection changes

class CRedirectionListener : public CBase, public MAknTransitionUtilsObserver

    {

private:

    TInt AknTransitionCallback( TInt aEvent, TInt aState,

            const TDesC8* /*aParams*/ )

        {

        if ( aEvent == CAknTransitionUtils::EEventWsBufferRedirection )

            {

            iRedirected = aState;

            if ( iCursorEnabled )

                {

                if ( iRedirected )

                    {

                    if ( iWg && iCursorStatus )

                        {

                        iWg->CancelTextCursor();

                        }

                    iCursorStatus = EFalse;

                    }

                else

                    {

                    iOwner.EnableCursor( ETrue );

                    }

                }

            }

        return 0;

        }

public:

    CRedirectionListener( CEikSecretEditor& aOwner ) : iOwner( aOwner )

        {

        RProperty::Get( KPSUidAvkonDomain, KAknTfxServerRedirectionStatus,

                        iRedirected );

        iRedirected &= ETfxScreenRedirected;

        }

    inline void EnableCursor()

        {

        iCursorEnabled = ETrue;

        }

    void DisableCursor()

        {

        if ( iWg && iCursorStatus )

            {

            iWg->CancelTextCursor();

            }

        iCursorEnabled = EFalse;

        iCursorStatus = EFalse;

        }

    void UpdateCursor( const TTextCursor& aCursor )

        {

        TInt redirected;

        RProperty::Get( KPSUidAvkonDomain, KAknTfxServerRedirectionStatus,

                        redirected );

        redirected &= ETfxScreenRedirected;

        if ( redirected != iRedirected && redirected )

            {

            AknTransitionCallback( CAknTransitionUtils::EEventWsBufferRedirection,

                                   1, NULL );

            return;

            }

        iRedirected = redirected;

        if ( iCursorEnabled && iWg && iWindow && !iRedirected )

            {

            iWg->SetTextCursor( *iWindow, iOwner.CursorPos(),

                                aCursor );

            iCursorStatus = ETrue;

            }

        }

    inline void SetWindows( RWindowGroup* aWg, RWindowBase* aWindow )

        {

        iWg = aWg;

        iWindow = aWindow;

        }

private:

    TBool iRedirected;

    TBool iCursorEnabled;

    TBool iCursorStatus;

    RWindowGroup* iWg;

    RWindowBase* iWindow;

    CEikSecretEditor& iOwner;

    };

#endif

/**

* Internal extension class for CEikSecretEditor.

*

* @since 2.0

*

* @internal

*/

class CEikSecretEditorExtension : public CBase

    {

public: // Construction and destruction

    CEikSecretEditorExtension()

    :iAknSkinColorIndex(KErrNotFound), 

    iSkinIdForBgColor(KErrNotFound), 

    iFeedback(MTouchFeedback::Instance())

                {

                }

    ~CEikSecretEditorExtension()

        {

        delete iExtendedInputCapabilitiesProvider;

        delete iExtendedInputCapabilities;

        }

    static CEikSecretEditorExtension* NewL()

        {

        CEikSecretEditorExtension* self =

        new ( ELeave ) CEikSecretEditorExtension;

        CleanupStack::PushL( self );

        self->ConstructL();

        CleanupStack::Pop();

        return self;

        }

    void ConstructL()

        {

        iExtendedInputCapabilities = 

        CAknExtendedInputCapabilities::NewL();

        TUint cap( iExtendedInputCapabilities->Capabilities() );

        cap |= CAknExtendedInputCapabilities::EInputEditorAlignBidi;

        iExtendedInputCapabilities->SetCapabilities( cap );

        iExtendedInputCapabilitiesProvider =

        new ( ELeave ) CAknExtendedInputCapabilities::

        CAknExtendedInputCapabilitiesProvider;

        iExtendedInputCapabilitiesProvider->SetExtendedInputCapabilities(

                iExtendedInputCapabilities );

        iExtendedInputCapabilities->SetEditorType( 

                CAknExtendedInputCapabilities::EEikSecretEditorBased );                

        }

public: // Data

    MAknsControlContext* iBgContext; // Not owned

    TBool iBgContextSet;

    TInt iAknSkinColorIndex;

    TInt iSkinIdForBgColor;

    MTouchFeedback* iFeedback;

    /**

     * Pointer to a CAknExtendedInputCapabilities.

     * Own.

     */

    CAknExtendedInputCapabilities* iExtendedInputCapabilities; 

    /**

     * Pointer to a extended input capabilities object provider.

     * Own.

     */

    CAknExtendedInputCapabilities::CAknExtendedInputCapabilitiesProvider*

    iExtendedInputCapabilitiesProvider;

    TInt iDisablePenInput; // Mainly for 0/1 values

    TTextCursor iCursor;

    RWindowGroup* iWg;

    RWindowBase* iWindow;

    TRect iTextRect;

    TBool iCursorEnabled;

    TBool iWindowSet;

    TBool iLaunchPenInputAutomatic;

    TBool iPartialScreenInput;

    TBool iLockQuerySCT;

    };

EXPORT_C void CEikSecretEditor::AknSetFont(const CFont &aFont)

    { 

    iFont = &aFont;

    iCharWidth=iFont->TextWidthInPixels(TPtrC((TText*)KSecretCharAsString, 1));

    CalculateAscent();

    }

EXPORT_C void CEikSecretEditor::AknSetAlignment(const CGraphicsContext::TTextAlign &aAlign) { iAlign = aAlign; }

EXPORT_C void CEikSecretEditor::SetDefaultInputMode(TInt aInputMode)

    {

    if (iFepState)

        {

        if ( aInputMode != EAknEditorNumericInputMode )

            {

            aInputMode = EAknEditorSecretAlphaInputMode;

            }

        CAknEdwinState* edwinState = STATIC_CAST(CAknEdwinState*, iFepState);

        edwinState->SetDefaultInputMode(aInputMode);

        edwinState->SetCurrentInputMode(aInputMode);

        }

    }

EXPORT_C CEikSecretEditor::CEikSecretEditor()

    : CEikBorderedControl(TGulBorder(TGulBorder::ESingleGray))

    {

    __DECLARE_NAME(_S("CEikSecretEditor"));

    const CFont* font=iCoeEnv->NormalFont();

    iFont = font;

    iCharWidth=font->TextWidthInPixels(TPtrC((TText*)KSecretCharAsString, 1));

    CalculateAscent();

    iAlign = CGraphicsContext::ELeft;

    AKNTASHOOK_ADD( this, "CEikSecretEditor" );

    }

EXPORT_C CEikSecretEditor::~CEikSecretEditor()

    {

    AKNTASHOOK_REMOVE();

#ifdef RD_UI_TRANSITION_EFFECTS_PHASE2

    CRedirectionListener* listener = ( CRedirectionListener* )

        CAknTransitionUtils::GetData( (TInt) this );

    if ( listener )

        {

        CAknTransitionUtils::RemoveObserver( listener,

            CAknTransitionUtils::EEventWsBufferRedirection );

        CAknTransitionUtils::RemoveData( (TInt) this );

        delete listener;

        }

#endif

    delete iInlineEditText;

    delete iFepState;

    delete iTimer;

    delete iSecCharArr;

    delete iExtension;

    }

EXPORT_C void CEikSecretEditor::ConstructFromResourceL(TResourceReader& aReader)

    //

    // Construct from resource

    //

    {

    iMaxLen=aReader.ReadUint16();

    __ASSERT_ALWAYS(iMaxLen<=EMaxSecEdSecArrayLength, Panic(EEikPanicSecretEditorTooLong));

    iSecCharArr = HBufC::NewL( EMaxSecEdSecArrayLength );

    iFepState = CreateFepStateL();

    if ( !iExtension )

        {

        iExtension = CEikSecretEditorExtension::NewL();

        }

    InitCRedirectionListenerL();

    }

void CEikSecretEditor::StartTimer()

    {

    iTimer->Start(KWait, KWait, TCallBack(TimerCallback, this));

    }

TInt CEikSecretEditor::TimerCallback(TAny* aThis)

    {

    static_cast<CEikSecretEditor*>(aThis)->Update();

    return NULL;

    }

EXPORT_C void CEikSecretEditor::Update()

    {

    if ( iTimer )

        {

        iTimer->Cancel();

        }

    InsertSecretChar();

    DrawDeferred();

    }

void CEikSecretEditor::OverflowAlert()

/**

Display alert to user, when character is entered but there is no more room in the field.

Current implementation is to play a sound alert.

@publishedComponent

*/

    {

    CAknKeySoundSystem* soundPlayer = (static_cast<CAknAppUi*>(CEikonEnv::Static()->AppUi()))->KeySounds();

    if(soundPlayer)

        {

        soundPlayer->PlaySound(EAvkonSIDWarningTone);

        }

    };

EXPORT_C TKeyResponse CEikSecretEditor::OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType)

    //

    // Respond to key presses

    //

    {

    if ( aType != EEventKey )

        {

        return EKeyWasConsumed;

        }

    TInt code=aKeyEvent.iCode;

    if ((code==EKeyUpArrow) || (code==EKeyDownArrow) || (aKeyEvent.iScanCode==EStdKeyHash) ||

    	(code==EKeyLeftArrow) || (code==EKeyRightArrow))

        return(EKeyWasNotConsumed);

    EnableCursor( EFalse );

    if ( ( code<ENonCharacterKeyBase  && TChar(code).IsPrint() ) || code == KPuaCodeSpaceSymbol)

        {

        if (iSecCharArr->Length()<iMaxLen)

            {

            AppendCharacterL( code );

            ReportEventL(MCoeControlObserver::EEventStateChanged);

            }

        else

            {

            iBufferFull=ETrue;

            OverflowAlert();

            }

        }

    if (iSecCharArr->Length()>0 && (code==EKeyBackspace || (code==EKeyF20 && !iBufferFull)))

        {

        iBufferFull=EFalse;

        TPtr secCharArrAppend = iSecCharArr->Des();

        secCharArrAppend.Delete(iSecCharArr->Length() - 1,1);

        Update();

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

        // If the text doesn't fit on line and a user presses backspace

        // it must be illustrated to the user that a char was deleted

        // (instead of just showing max amount of KSecretChars).

        if ( iSecCharArr->Length() >= CharsFitOnEditor() )

            {

            if (!iTimer)

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

            if (iTimer->IsActive())

                Update();

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

            DrawDeferred();

            StartTimer();

            }

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

        if ( iSecCharArr->Length() == 0 )

            {

            EnableCursor( ETrue );

            }

        ReportEventL(MCoeControlObserver::EEventStateChanged);

        }

    if ( code != EKeyF20 )

        {

        ReportUpdate();

        }

    return EKeyWasConsumed;

    }

EXPORT_C TSize CEikSecretEditor::MinimumSize()

    //

    // Returns the minimum size needed to display

    //

    {

    TSize size=iBorder.SizeDelta();

    const CAknLayoutFont* layoutFont = CAknLayoutFont::AsCAknLayoutFontOrNull( iFont );

    if ( layoutFont )

        {

        size.iHeight += layoutFont->TextPaneHeight();

        }

    else

        {

        size.iHeight += iFont->HeightInPixels();

        }

    TAknTextDecorationMetrics decoration( iFont );

    TInt leftMargin(0);

    TInt rightMargin(0);

    decoration.GetLeftAndRightMargins( rightMargin, leftMargin );

    size.iWidth+=iCharWidth*(iMaxLen+1)+rightMargin + leftMargin; // 1 is for the cursor 

    return size;

    }

EXPORT_C TCoeInputCapabilities CEikSecretEditor::InputCapabilities() const

    {

    TCoeInputCapabilities inputCaps( 

        TCoeInputCapabilities::ESecretText|TCoeInputCapabilities::ENavigation,

        const_cast<CEikSecretEditor*>( this ),

        NULL );

    if ( iExtension )

        {

        inputCaps.SetObjectProvider( iExtension->iExtendedInputCapabilitiesProvider );

        }

    return inputCaps;

    }

EXPORT_C void CEikSecretEditor::GetText(TDes& aText) const

    //

    // Get the actual text typed

    //

    {

    // Check the buffer passed relative to the maximum number of characters enterable.

    // This will cause the panic to occur earlier and not depend upon how many characters 

    // have actually been entered

    __ASSERT_ALWAYS( aText.MaxLength() >= iMaxLen, Panic(EEikPanicSecretEditorTooLong));

    aText.Copy( *iSecCharArr );

    }

EXPORT_C void CEikSecretEditor::SetText( const TDesC& aText )

    {

    //

    // Initialize editor (the buffer and the display)

    //

    __ASSERT_ALWAYS( aText.Length() <= iMaxLen, Panic(EEikPanicSecretEditorTooLong));

    TPtr secCharArrAppend = iSecCharArr->Des();

    secCharArrAppend.Zero();

    iBuf.Zero();

    secCharArrAppend.Append( aText );

    InsertSecretChar();

    ReportUpdate();

    DrawDeferred();

    UpdateCursor();

    }

EXPORT_C void CEikSecretEditor::InitializeDisplay( TInt aNumberOfChars )

    {

    //

    // Initialize display with KSecretChars, doesn't affect the actual buffer.

    //

    __ASSERT_ALWAYS( aNumberOfChars <= iBuf.MaxLength(), Panic(EEikPanicSecretEditorTooLong));

    Reset();

    iBuf.Fill(KSecretChar, aNumberOfChars);

    ReportUpdate();

    DrawDeferred();

    }

EXPORT_C void CEikSecretEditor::Reset()

    //

    // Clear the text

    //

    {

    TPtr secCharArrAppend = iSecCharArr->Des();

    secCharArrAppend.Zero();

    iBuf.Zero();

    ReportUpdate();

    DrawDeferred();

	UpdateCursor();

    }

EXPORT_C void CEikSecretEditor::SetMaxLength(TInt aMaxLength)

    //

    // Set the maximum number of characters for the secret editor

    //

    {

    iMaxLen=aMaxLength;

    __ASSERT_ALWAYS(iMaxLen<=EMaxSecEdSecArrayLength, Panic(EEikPanicSecretEditorTooLong));

    // Docs claim that CEikSecretEditor's 2nd stage construction can be

    // done either by ConstructFromResourceL() or SetMaxLength().

    // We'll have to at least try to create extension here, sadly adding to the

    // iExtension creation mess already prevalent in this class.

    if ( !iExtension )

        {

        TRAP_IGNORE ( iExtension = CEikSecretEditorExtension::NewL() );

        }

    }

EXPORT_C void CEikSecretEditor::Draw(const TRect& /*aRect*/) const

    //

    // Draw the whole secret editor

    //

    {

    CWindowGc& gc=SystemGc();