/*
* Copyright (c) 2002-2004 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:            Provides the TAknFepUiInputStateInitialFullNumber methods.
*
*/












// INCLUDE FILES
#include "AknFepUiInputStateInitialFullNumber.h"
#include "AknFepUIManagerStateInterface.h"   // MAknFepUIManagerStateInterface
#include "AknFepManagerUIInterface.h"        // MAknFepManagerUIInterface
#include "AknFepManager.h"

#include <PtiEngine.h>
#include <featmgr.h>                //FeatureManager
#include <PtiCompositionDataIF.h>        // MPtiEngineCompositionDataInterface
#include <jplangutil.h>

// CONSTANTS
const TInt KNumAllowedIdleNumericChars = 21;

_LIT(KAknFepPlainNumbers, "1234567890");
const TUint16 KAllAllowedNumericChars[] =
    {'*','+','p','w','#','1','2','3','4','5','6','7','8','9','0', ';','.',',','-','E','?'};
const TKeyEvent KEventsForSecondPass[]  =
    {
        {42, EStdKeyNkpAsterisk, 3, 0},
        {43, EStdKeyNkpPlus, 3, 0},
        {112, 80, EModifierAutorepeatable, 0},
        {119, 87, EModifierAutorepeatable, 0},
        {35, EStdKeyHash, EModifierAutorepeatable, 0},
        {EPtiKey1, EPtiKey1, EModifierAutorepeatable, 0},
        {EPtiKey2, EPtiKey2, EModifierAutorepeatable, 0},
        {EPtiKey3, EPtiKey3, EModifierAutorepeatable, 0},
        {EPtiKey4, EPtiKey4, EModifierAutorepeatable, 0},
        {EPtiKey5, EPtiKey5, EModifierAutorepeatable, 0},
        {EPtiKey6, EPtiKey6, EModifierAutorepeatable, 0},
        {EPtiKey7, EPtiKey7, EModifierAutorepeatable, 0},
        {EPtiKey8, EPtiKey8, EModifierAutorepeatable, 0},
        {EPtiKey9, EPtiKey9, EModifierAutorepeatable, 0},
        {EPtiKey0, EPtiKey0, EModifierAutorepeatable, 0},
        {59,       EStdKeySemiColon, EModifierAutorepeatable, 0},
        {46,       122, EModifierAutorepeatable, 0},
        {44,       121, EModifierAutorepeatable, 0},
        {45,       130, EModifierAutorepeatable, 0},
        {101,      69,  EModifierAutorepeatable|EModifierLeftShift, 0},
        {63,       EStdKeyForwardSlash, EModifierAutorepeatable|EModifierLeftShift, 0}
    };

/**
 *  AknFepUiInputStateInitialFullNumber class.
 *
 */
//============================ MEMBER FUNCTIONS ==============================

// ---------------------------------------------------------------------------
// TAknFepUiInputStateInitialFullNumber::TAknFepUiInputStateInitialFullNumber
// C++ default Constructor
// ---------------------------------------------------------------------------
//
TAknFepUiInputStateInitialFullNumber::TAknFepUiInputStateInitialFullNumber(
                                MAknFepUIManagerStateInterface* aOwner,
                                MAknFepUICtrlContainerJapanese* aUIContainer)
    :TAknFepUiInputStateInitialJapaneseBase(aOwner, aUIContainer)
    {
    }

// ---------------------------------------------------------------------------
// TAknFepUiInputStateInitialFullNumber::InitializeStateL
// Initialize State
// ---------------------------------------------------------------------------
//
void TAknFepUiInputStateInitialFullNumber::InitializeStateL()
    {
    TAknFepUiInputStateInitialJapaneseBase::InitializeStateL();

    // Setup PtiEngine
    CPtiEngine* ptiEngine = iOwner->PtiEngine();
    const TWidthChar width = iOwner->FepMan()->CharacterWidth();
    TPtiEngineInputMode inputmode = EPtiEngineInputModeNone;
    switch(width)
        {
        case EHalfWidthChar:
            inputmode = (iOwner->IsQwerty())?
                            EPtiEngineQwerty
                            : EPtiEngineNumeric;
            break;

        case EFullWidthChar:
            inputmode = (iOwner->IsQwerty())?
                            EPtiEngineFullWidthNumericQwerty
                            : EPtiEngineFullWidthNumeric;
            break;

        default: // no operation
            break;
        }
    if (inputmode != EPtiEngineInputModeNone)
        {
        ptiEngine->SetInputMode(inputmode);

        if (inputmode == EPtiEngineNumeric)
            {
            TRAP_IGNORE(ptiEngine->SetExternalKeyMapL(EPtiEngineNumeric, EPtiKeyStar, 
                                                     (TDesC&)iOwner->NumberModeKeyMapping(), 
                                                      EPtiCaseLower))
            }
        }

    ptiEngine->ClearCurrentWord();
    }

TBool TAknFepUiInputStateInitialFullNumber::HandleKeyL(TInt aKey, TKeyPressLength aLength)
    {
    CPtiEngine* ptiengine = iOwner->PtiEngine();
    MAknFepManagerUIInterface* fepMan = iOwner->FepMan();
    TBool rtn = EFalse;

    switch(ptiengine->InputMode())
        {
        case EPtiEngineNumeric:         // non-Qwerty number input
            rtn = HandleOwnKeyL(aKey, aLength);
            break;
        case EPtiEngineQwerty:                  // Qwerty number input
        case EPtiEngineFullWidthNumericQwerty:  // Qwerty full-width number input
            rtn = HandleQwertyKeyL(aKey, aLength, fepMan->CharacterWidth());
            break;
        case EPtiEngineFullWidthNumeric:    // non-Qwerty full-width number input
            rtn = TAknFepUiInputStateInitialJapaneseBase::HandleKeyL(aKey, aLength);
            break;
        default:
            break;
        }
    return rtn;
    }

TBool TAknFepUiInputStateInitialFullNumber::HandleOwnKeyL(TInt aKey, TKeyPressLength aLength)
    {
    CPtiEngine* ptiengine = iOwner->PtiEngine();
    MAknFepManagerUIInterface* fepMan = iOwner->FepMan();

    if (aLength == ELongKeyPress)
        {
        switch (aKey)
            {
        case EKeyRightArrow:
        case EKeyLeftArrow:
        case EKeyDownArrow:
        case EKeyUpArrow:
        case EKeyBackspace:
            return EFalse;
        case EPtiKeyStar:
             if (!fepMan->HashKeySelectionInUse()
              && fepMan->EditSubmenuInUse())
                {
                fepMan->LaunchSpecialCharacterTableL();
                }
        default:
            return ETrue;
            }
        }

    if(aKey == EPtiKeyStar)
        {
        TBool append = EFalse;
        if (aLength == EShortKeyPress)
            {
            if (fepMan->EditSubmenuInUse())
                {
                if (fepMan->IsOnlyNumericPermitted())
                    {
                    append = ETrue;
                    }
                else
                    {
                    fepMan->ClearCcpuFlag(CAknFepManager::ECcpuStateIgnoreStarUp);
                    }
                }
            else
                {
                if (fepMan->IsAbleToLaunchSCT())
                    {
                    fepMan->LaunchSpecialCharacterTableL();
                    }
                else
                    {
                    append = ETrue;
                    }
                }
            }
        else
            {
            if (fepMan->EditSubmenuInUse() && fepMan->IsAbleToLaunchSCT())
                {
                fepMan->LaunchSpecialCharacterTableL();
                }
            }
        if (append)
            {
            iData = aKey;
            TPtrC text = ptiengine->AppendKeyPress((TPtiKey)aKey);

            // star key is inactive if keymapping is empty.
            if (text.Length() > 0 && text[0] != 0)
                {
                fepMan->NewCharacterL(text);

                // Commit immediately if there is only one character associated to the key.
                TBuf<CAknFepManager::EMaximumFepWordLength> mapdata;
                ptiengine->MappingDataForKey((TPtiKey)aKey, mapdata, ptiengine->Case());
                if (mapdata.Length() <= 1)
                    {
                    fepMan->CommitInlineEditL();
                    ptiengine->ClearCurrentWord();
                    iData = 0;
                    }
                }
            }

        return ETrue;
        }

    if(iData)
        {
        fepMan->CommitInlineEditL();
        ptiengine->ClearCurrentWord();

        iData = 0;
        }
    return EFalse;
    }

TBool TAknFepUiInputStateInitialFullNumber::HandleQwertyKeyL(TInt aKey, 
                                            TKeyPressLength /*aLength*/, const TWidthChar aWidth)
    {
    TBool rtn = EFalse;

    MAknFepManagerUIInterface* fepMan = iOwner->FepMan();
    CAknFepCaseManager* caseMan = iOwner->CaseMan();
    CPtiEngine* ptiengine = iOwner->PtiEngine();

    fepMan->ClearFlag(CAknFepManager::EFlagNoActionDuringShiftKeyPress);

    if ( fepMan->IsOnlyNumericPermitted() )
        {
        if (aKey == EStdKeySpace || aKey == EStdKeyEnter)
            {
            // return Consumed
            return ETrue;
            }
        if (!IsQwertyKey(aKey))
            {
            // return Not Consumed
            return EFalse;
            }

        TChar chr(0);
        TKeyEvent numKey;

        ptiengine->AppendKeyPress((TPtiKey)aKey);
        const MPtiEngineCompositionDataInterface* data = ptiengine->CompositionData();
        TPtrC text = data->CompletedString();
        if (text.Length() > 0 && text[0] != 0)
            {
            TChar compchar = text[0];
            if (aWidth == EFullWidthChar)
                {
                TBuf<2> halfstring;
                TInt convlen = JPLangUtil::ConvertFullToHalfWidth(
                                text.Left(1), halfstring);
                if (convlen > 0)
                    {
                    compchar = halfstring[0];
                    }
                }
            for (TInt i = 0; i < KNumAllowedIdleNumericChars; i++)
                {

                if (compchar == KAllAllowedNumericChars[i])
                    {
                    numKey = KEventsForSecondPass[i];
                    chr = KAllAllowedNumericChars[i];
                    break;
                    }
                }
            }

        if ((chr != 0) &&
            ((iOwner->NumberModeKeyMapping().Locate(chr) != KErrNotFound) ||
             (KAknFepPlainNumbers().Locate(chr) != KErrNotFound)) ||
             fepMan->IsAllowedKeymappingForNumberMode(chr))
            {
            if (aWidth == EFullWidthChar)
                {
                // Full-width characters are committed immediately.
                fepMan->NewCharacterL(text);
                fepMan->CommitInlineEditL();
                }
            else
                {
                // If editor is in number mode and incoming key press would produce
                // any of the allowed number mode characters,
                // resend suitable key event let it pass through FEP. That way phone idle
                // receives the event too. This also takes care of remapping
                // different qwerty keymap layouts to edwin events.
                fepMan->SetFlag(CAknFepManager::EFlagPassNextKey);
                CCoeEnv::Static()->SimulateKeyEventL(numKey, EEventKey);
                }
            }
        ptiengine->ClearCurrentWord();

        return ETrue;
        }

    return rtn;
    }



// Functions from MPtiObserver interface
void TAknFepUiInputStateInitialFullNumber::KeyTimerExpired()
    {
    if (iData)
        {
        MAknFepManagerUIInterface* fepMan = iOwner->FepMan();
        TRAP_IGNORE(fepMan->CommitInlineEditL())

        CPtiEngine* ptiengine = iOwner->PtiEngine();
        ptiengine->ClearCurrentWord();

        iData = 0;
        }
    }

// End of file