/*

* 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 CAknFepUIManagerJapanese methods.

*

*/

// INCLUDE FILES

#include <e32svr.h> // RDebug stuff...

#include <txtfrmat.h>

#include <e32keys.h>

#include "AknFepGlobalEnums.h"

#include "AknFepUiManagerBase.h"

#include "AknFepUIManagerJapanese.h"

#include "AknFepManagerInterface.h"         // MAknFepManagerInterface

#include "AknFepUIManagerStateInterface.h"  // MAknFepUIManagerStateInterface

#include "AknFepManagerUIInterface.h"

#include "AknFepGlobalEnums.h"

#include "AknFepCaseManager.h"

#include "AknFepUiInputStateInitialHiraganaKanji.h"

#include "AknFepUiInputStateInitialHiragana.h"

#include "AknFepUiInputStateInitialKatakana.h"

#include "AknFepUiInputStateInitialLatinJapanese.h"

#include "AknFepUiInputStateInitialFullNumber.h"

#include "AknFepUiInputStateEntryJapaneseMultitap.h"

#include "AknFepUiInputStateEntryHiraganaKanji.h"

#include "AknFepUiInputStateEntryKatakana.h"

#include "AknFepUiInputStateEntryLatinJapanese.h"

#include "AknFepUiInputStateConversionHiraganaKanji.h"

#include "AknFepUiInputStateCandidateHiraganaKanji.h"

#include "AknFepUiInputStateCompletionHiraganaKanji.h"

#include "AknFepUiInputStateCompletionPredictiveHiraganaKanji.h"

#include "AknFepUiInputStateCompletionJapaneseMultitap.h"

#include "AknFepUiInputStateCompletionKatakana.h"

#include "AknFepUiInputStateCompletionLatinJapanese.h"

#include "AknFepUiInputStatePredictiveInputJapanese.h"

#include "AknFepUiInputStateNextWordJapanesePredictive.h"

#include "AknFepUICtrlContainerJapanese.h"

#include "AknFepPanic.h"

#include "AknFepUiInputStateCandidateRetroActive.h"

#include <AknIndicatorContainer.h>  // CAknIndicatorContainer::TIndicatorContext

#include <PtiEngine.h>

#include <PtiCompositionDataIF.h>   // MPtiEngineCompositionDataInterface

#include <PtiDefs.h>                // keys

// CONSTANTS

// LOCAL FUNCTION PROTOTYPES

static TBool IsNumericKey(TInt aKey);

static TBool IsQwertyKey(TInt aKey);

//============================ LOCAL FUNCTIONS ==============================

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

// IsNumericKey

//

// Returns: ETrue is returned if aKey is number key

//

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

//

static TBool IsNumericKey(const TInt aKey)

    {

    TBool response = EFalse;

    if (aKey >= EPtiKeyQwerty0 && aKey <= EPtiKeyQwerty9)

        {

        response = ETrue;

        }

    return response;

    }

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

// IsQwertyKey

//

// Returns: ETrue is returned if aKey is qwerty key

//

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

//

static TBool IsQwertyKey(const TInt aKey)

    {

    TBool response = EFalse;

    if ( (aKey >= EPtiKeyQwertyA && aKey <= EPtiKeyQwertyZ) ||

        IsNumericKey( aKey ) ||

        aKey == EStdKeySpace ||

        aKey == EPtiKeyQwertyPlus ||

        aKey == EPtiKeyQwertyMinus ||

        aKey == EPtiKeyQwertyComma ||

        aKey == EPtiKeyQwertySemicolon ||

        aKey == EPtiKeyQwertyFullstop ||

        aKey == EPtiKeyQwertyHash ||

        aKey == EPtiKeyQwertySlash ||

        aKey == EPtiKeyQwertyApostrophe)

        {

        response = ETrue;

        }

    return response;

    }

/**

 *  CAknFepUIManagerJapanese class.

 *

 */

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

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

// CAknFepUIManagerJapanese::NewL

//

//

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

//

CAknFepUIManagerJapanese* CAknFepUIManagerJapanese::NewL(MAknFepManagerUIInterface* aFepMan,

                                                         CAknFepCaseManager* aCaseMan,

                                                         TLanguage aLanguage)

    {

    CAknFepUIManagerJapanese* self = new(ELeave)CAknFepUIManagerJapanese(aFepMan, aCaseMan);

    CleanupStack::PushL(self);

    self->ConstructL(aLanguage);

    CleanupStack::Pop(self);

    return self;

    }

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

// CAknFepUIManagerJapanese::~CAknFepUIManagerJapanese

//

//

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

//

CAknFepUIManagerJapanese::~CAknFepUIManagerJapanese()

    {

    delete iCandidateArray;

    delete iContainerPane;

    }

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

// CAknFepUIManagerJapanese::SetCase

//

//

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

//

void CAknFepUIManagerJapanese::SetCase(TCase aCase)

    {

    CAknFepUIManagerBase::SetCase(aCase);

    if (iMode != ENumber)

        {

        if (!iCaseMan->IsAbleChangeCase())

            {

            if (iCaseMan->CurrentCase() == EAknEditorLowerCase)

                {

                TRAP_IGNORE(iPtiEngine->HandleCommandL(EPtiCommandUseLatinCaseLowerOnlyKeyMap));

                }

            else if (iCaseMan->CurrentCase() == EAknEditorUpperCase)

                {

                TRAP_IGNORE(iPtiEngine->HandleCommandL(EPtiCommandUseLatinCaseUpperOnlyKeyMap));

                }

            }

        else

            {

            TRAP_IGNORE(iPtiEngine->HandleCommandL(EPtiCommandUseLatinDefaultKeyMap));

            }

        }

    }

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

// CAknFepUIManagerJapanese::HandleKeyL

//

//

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

//

TBool CAknFepUIManagerJapanese::HandleKeyL(TInt aKey, TKeyPressLength aLength, TEventCode /*aEventCode*/)

    {

    TUIState currentState = iFepUiState.State();

    if (aLength == EShortKeyPress)

        {

        iInitialFepUIState = currentState;

        }

    // If current input mode is Number or Hiragana,

    // numeric long keypress doesn't operate.

    if (iMode == ENumber || iMode == EHiragana)

        {

        if (IsNumericKey(aKey) && aLength == ELongKeyPress)

            {

            return ETrue;

            }

        }

    if (iMode == EHiragana)

        {

        if( aKey == EPtiKeyStar && aLength == ELongKeyPress)

            {

            return ETrue;

            }

        }

    // CBA keypress is valid when input state is Initial, Entry

    // Predictive input or NextWord.

    switch (aKey)

        {

        case EKeyCBA1:          // ITU-T left softkey

        case EKeyCBA2:          // ITU-T right softkey

        case EStdKeyDevice0:    // Qwerty left softkey (=0xa4)

        case EStdKeyDevice1:    // Qwerty right softkey(=0xa5)

            // In case of Latin and Number, all characters must be committed.

            if (iMode != EHiraganaKanji)

                {

                CloseUI();

                }

            switch (iStatePtr->State())

                {

                case EInitial:

                case EEntry:

                case EPredictiveInput:

                case ENextWord:

                    return EFalse;

                default:

                    return ETrue;

                }

            //break;  not needed

        default:

            // move to next line

            break;

        }

    TPtiTextCase oldPtiCaseMode = iPtiEngine->Case();

    TPtiTextCase caseMode = EPtiCaseLower;

    TPtiTextCase shiftedCase = caseMode;

    if (IsQwerty())

        {

        caseMode = EPtiCaseLower;

        if (!FepMan()->IsOnlyNumericPermitted())

            {

            caseMode = oldPtiCaseMode;

            if (iMode & (EHiraganaKanji|EHiragana|EKatakana))

                {

                if (CaseMan()->CurrentCase() == EAknEditorTextCase

                 && caseMode == EPtiCaseUpper

                 && iStatePtr->State() == EInitial)

                    {

                    iPtiEngine->SetCase(EPtiCaseLower);

                    caseMode = EPtiCaseLower;

                    oldPtiCaseMode = EPtiCaseLower;

                    }

                }

            else if (iMode == ELatin)

                {

                switch (CaseMan()->CurrentCase())

                    {

                    case EAknEditorUpperCase:

                    case EAknEditorTextCase:

                        caseMode = EPtiCaseUpper;

                        break;

                    case EAknEditorLowerCase:

                    default:

                        caseMode = EPtiCaseLower;

                        break;

                    }

                }

            }

        shiftedCase = caseMode;

        if ( FepMan()->IsFlagSet(CAknFepManager::EFlagQwertyShiftMode) )

            {

            // while pressing Shift key

            if ( aKey >= EPtiKeyQwertyA && aKey <= EPtiKeyQwertyZ )

                {

                shiftedCase = (caseMode != EPtiCaseUpper)? EPtiCaseUpper : EPtiCaseLower;

                }

            else

                {

                // except alpha key

                shiftedCase = EPtiCaseUpper;

                }

            }

        else if (!(aKey >= EPtiKeyQwertyA && aKey <= EPtiKeyQwertyZ))

            {

            // out of A-Z key

            shiftedCase = EPtiCaseLower;

            }

        if (shiftedCase != oldPtiCaseMode)

            {

            iPtiEngine->SetCase(shiftedCase);

            }

        }

    TBool ret = iStatePtr->HandleKeyL(aKey, aLength);

    // If the state was changed by keypress event and not handle keypress event,

    // changed state handle it keypress event.

    while (!ret && currentState != iFepUiState.State())

        {

        // If editor was filled by characters,

        // don't handle no more numeric keypress or qwerty keypress

        if (iStatePtr->State() == EInitial

         && !FepMan()->EditorHasFreeSpace())

            if (!IsQwerty() && IsNumericKey(aKey))

                {

                return ETrue;

                }

            else if (IsQwerty() && IsQwertyKey(aKey))

                {

                return ETrue;

                }

        if ( (IsQwerty())

          && (iPtiEngine->Case() != shiftedCase) )

            {

            iPtiEngine->SetCase(shiftedCase);

            }

        currentState = iFepUiState.State();

        ret = iFepUiState.HandleKeyL(aKey, aLength);

        }

    if (IsQwerty())

        {

        if (oldPtiCaseMode != iPtiEngine->Case())

            {

            iPtiEngine->SetCase(oldPtiCaseMode);

            }

        }

    return ret;

    }

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

// CAknFepUIManagerJapanese::CloseUI

//

//

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

//

void CAknFepUIManagerJapanese::CloseUI()

    {

    if (iStatePtr->State() != EInitial)

        {

        iStatePtr->CloseUI();

        if (iStatePtr->State() == EMultiCompletion)

            {

            ChangeState(EInitial);

            }

        else

            {

            // Commit Uncommited string

            if (iStatePtr->State() != ENextWord)

                {

                ChangeState(EMultiCompletion);

                }

            TRAP_IGNORE(iStatePtr->HandleCommandL(EAknFepAllCompletion));

            }

        }

    }

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

// CAknFepUIManagerJapanese::GetFormatOfFepInlineText

//

//

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

//

void CAknFepUIManagerJapanese::GetFormatOfFepInlineText(TCharFormat& aFormat,

                                                        TInt& aNumberOfCharactersWithSameFormat,

                                                        TInt aPositionOfCharacter) const

    {

    TRgb highlightColor1 = AKN_LAF_COLOR_STATIC(244);

    TRgb highlightColor2 = AKN_LAF_COLOR_STATIC(210);

    TRgb textColor = AKN_LAF_COLOR_STATIC(0);

    if ((iFepUiState.State() == EEntry)

     || (iFepUiState.State() == EConversion)

     || (iFepUiState.State() == ECandidate)

     || (iFepUiState.State() == ECandidateRetroActive)

     || (iFepUiState.State() == EPredictiveInput))

        {

        const MPtiEngineCompositionDataInterface* data = PtiEngine()->CompositionData();

        TInt length = 0;

        TInt clauseCount = 0;

        TInt preLength = 0;

        TPtrC8 clauseChar = data->LengthOfPhrase();

#ifdef __ITI_LONGPRESS_NUM_SHIFT_COPYPASTE__

#ifdef RD_INTELLIGENT_TEXT_INPUT

        if ( clauseChar.Length() )

           {

#endif //RD_INTELLIGENT_TEXT_INPUT

#endif // __ITI_LONGPRESS_NUM_SHIFT_COPYPASTE__        

        for (; length < aPositionOfCharacter; ++clauseCount)

            {

            preLength = length;

            length += clauseChar[clauseCount];

            }

        if (length == aPositionOfCharacter)

            aNumberOfCharactersWithSameFormat = clauseChar[clauseCount];

        else

            {

            --clauseCount;

            aNumberOfCharactersWithSameFormat = clauseChar[clauseCount]

                                                + preLength

                                                - aPositionOfCharacter;

            }

        switch (data->AttributeOfPhrase()[clauseCount])

            {

            //Input phase

            case MPtiEngineCompositionDataInterface::EPtiAttributeTransitoryInput:

                {

                if (iFlagInlineEditUnderline)

                    {

                    aFormat.iFontPresentation.iHighlightColor = highlightColor1;

                    aFormat.iFontPresentation.iHighlightStyle = TFontPresentation::

                                                                EFontHighlightNormal;

                    }

                else

                    {

                    }

                }

                break;

            // Conversion phase(no target phrase)

            case MPtiEngineCompositionDataInterface::EPtiAttributeNonTargetConvert:

                {

                aFormat.iFontPresentation.iHighlightColor = highlightColor1;

                aFormat.iFontPresentation.iHighlightStyle = TFontPresentation::

                                                            EFontHighlightNormal;

                }

                break;

            // Conversion phase(target Phrase)

            case MPtiEngineCompositionDataInterface::EPtiAttributeTargetConvert:

                {

                aFormat.iFontPresentation.iTextColor = textColor;

                aFormat.iFontPresentation.iHighlightColor = highlightColor2;

                aFormat.iFontPresentation.iHighlightStyle = TFontPresentation::

                                                            EFontHighlightNormal;

                }

                break;

            default:

                break;

#ifdef __ITI_LONGPRESS_NUM_SHIFT_COPYPASTE__

#ifdef RD_INTELLIGENT_TEXT_INPUT

						}

#endif // RD_INTELLIGENT_TEXT_INPUT

#endif // __ITI_LONGPRESS_NUM_SHIFT_COPYPASTE__              

            }

        }

        else if (iFepUiState.State() == EMultiCompletion)

            {

            const MPtiEngineCompositionDataInterface* data = PtiEngine()->CompositionData();

            TInt length = data->CompletedString().Length();

            // Panic in case (aNumberOfCharactersWithSameFormat < 1)

            if( !(length > 0) )

               {

               length = 1;

               }

            aNumberOfCharactersWithSameFormat = length;

        }

    }

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

// CAknFepUIManagerJapanese::IsValidShiftKeyPress

//

//

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

//

TBool CAknFepUIManagerJapanese::IsValidShiftKeyPress() const

    {

    TBool ret = ETrue;

    switch (iMode)

        {

        case EHiraganaKanji:

            // ITU-T has to check Edit-key(= Shift-key). If the state is Initial

            // or NextWord, Edit-key is valid, the other states are invalid.

            // However, in Qwerty input, shift-key is used for changing Case mode,

            // so, shift-key is always valid even if the statue is anything.

            if (!iQwerty)

                {

                if (iStatePtr->State() == EInitial || iStatePtr->State()== ENextWord)

                    {

                    ret = ETrue;

                    }

                else

                    {

                    ret = EFalse;

                    }

                }

            break;

        case EHiragana:

            ret = EFalse;

            break;

        case EKatakana:

        default:

            break;

        }

    return ret;

    }

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

// CAknFepUIManagerJapanese::ChangeState

//

//

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

//

TUIState CAknFepUIManagerJapanese::ChangeState(TUIState aState)

    {

    switch(aState)

        {

        case EInitial:

            {

            switch(iMode)

                {

                case EHiragana:

                    iFepUiState = TAknFepUiInputStateInitialHiragana(this, UIContainer());