/*

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

*

*/

#include "AknFepCaseManager.h"

#include "AknFepPanic.h"

#include "aknfeppeninputenums.h"

#include <AknFep.rsg>

#include <aknedsts.h>

#include <barsread.h>

#include <jplangutil.h>

#include <AknPictographInterface.h>

#include <AknPictographDrawerInterface.h>

#include <featmgr.h>

#include <PUAcodes.hrh>

const TText KSpaceCharacter=' ';

const TText KInvertedExclamationMarkCharacter = 0x00A1;

const TText KInvertedQuestionMarkCharacter = 0x00BF;

/* Teleca change begin, 18.08.2009 ssal */

const TInt KSBase = 0xac00; // base address for hangul syllables

const TInt KCBase = 0x3131; // base address for hangul compatibility jamo

const TInt KLCount = 19; // count of L-jamos

const TInt KVCount = 21; // count of V-jamos

const TInt KTCount = 28; // count of T-jamos

const TInt KNCount = KVCount * KTCount; // count of V&T-jamo combinations

const TInt KSCount = KLCount * KNCount; // total count of hangul syllables

// Conversion table for hangul compatibility jamo

const TUint16 conversionTableFromCompatibilityJamoToJamo[] = {

0x1100,

0x1101,

0x11AA,

0x1102,

0x11AC,

0x11AD,

0x1103,

0x1104,

0x1105,

0x11B0,

0x11B1,

0x11B2,

0x11B3,

0x11B4,

0x11B5,

0x11B6,

0x1106,

0x1107,

0x1108,

0x11B9,

0x1109,

0x110A,

0x110B,

0x110C,

0x110D,

0x110E,

0x110F,

0x1110,

0x1111,

0x1112,

0x1161,

0x1162,

0x1163,

0x1164,

0x1165,

0x1166,

0x1167,

0x1168,

0x1169,

0x116A,

0x116B,

0x116C,

0x116D,

0x116E,

0x116F,

0x1170,

0x1171,

0x1172,

0x1173,

0x1174,

0x1175,

};

#define KCCount (sizeof(conversionTableFromCompatibilityJamoToJamo) / sizeof(TUint16))

/* Teleca change end, 18.08.2009 ssal */

// 0x2029 is the paragraph seperator. When the user inputs a

// new line character, 0x2029 is inserted.

const TText KParagraphSeperator = 0x2029;

// 0x000A is line feed character 

const TText KLineFeed = 0x000A;

//for chinese unicode ox4E00 to 0x9FA5

const TText KChineseLowerUnicode = 0x4E00;

const TText KChineseUpperUnicode = 0x9FA5;

CAknFepCaseManager* CAknFepCaseManager::NewL(CAknFepManager& aFep)

    {

    CAknFepCaseManager* self = new (ELeave) CAknFepCaseManager(aFep);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(); //self

    return self;

    }

CAknFepCaseManager::~CAknFepCaseManager()

    {

    delete iPictoInterface;

    }

void CAknFepCaseManager::ConfigureCaseStateFromEditorState()

    {

    CAknEdwinState* editorState = iFep.EditorState();

    if (!editorState)

        {

        return;

        }

 	iCurrentCase = editorState->CurrentCase();   

    iPreviousCase = editorState->CaseState().PreviousCase();    

    SetFixedCase(editorState->Flags() & EAknEditorFlagFixedCase);

    iPreviousCase = iCurrentCase;

  	if (CurrentEditorIsFixedCase())

    	{    

    	SetCurrentCase(editorState->DefaultCase()); 

    	iPreviousCase = iCurrentCase; 

    	__ASSERT_DEBUG(IsCasePermitted(iCurrentCase), 

                     AknFepPanic(EAknFepPanicNonPermittedEditorMode));		   	

    	} 

    //determine it based on position 

    UpdateCase(ENullNaviEvent);

    // if still there is no current case set - use the default

    if (!iCurrentCase)

        {

        SetCurrentCase(editorState->DefaultCase());

        if (!IsCasePermitted(iCurrentCase))

            {

            SetCurrentCase(editorState->CurrentCase());

            }

        iPreviousCase = iCurrentCase;

        __ASSERT_DEBUG(IsCasePermitted(iCurrentCase), 

                       AknFepPanic(EAknFepPanicNonPermittedEditorMode));

        }

    // if the current is not allowed stay where we are

    else if (!IsCasePermitted(iCurrentCase))

        {

        if (!iPreviousCase)

            {

            SetCurrentCase(editorState->DefaultCase());

            iPreviousCase = iCurrentCase;

            __ASSERT_DEBUG(IsCasePermitted(iCurrentCase), 

                           AknFepPanic(EAknFepPanicNonPermittedEditorMode));

            }

        else

            {

            if (IsCasePermitted(iPreviousCase))

                {

                SetCurrentCase(iPreviousCase);

                }

            else

                {

                SetCurrentCase(editorState->DefaultCase());

                iPreviousCase = iCurrentCase;

                __ASSERT_DEBUG(IsCasePermitted(iCurrentCase), 

                               AknFepPanic(EAknFepPanicNonPermittedEditorMode));

                }    

            }

        }

    }

void CAknFepCaseManager::UpdateCase(TWesternNaviEvent aNaviEvent)

    {

    TBool applyCaseNeeded = ETrue;

    if ( iFep.IsFlagSet(CAknFepManager::EFlagSupressAutoUpdate) )

        {

        return;

        }

    CAknEdwinState* editorState = iFep.EditorState();

    if (!CurrentEditorIsFixedCase() && editorState 

      && editorState->PermittedCases() & EAknEditorTextCase)

        {

        // lets figure out where the cursor will be when the case needs to be checked

        TInt cursorPos = FindCursorPositionAtCaseCheck(aNaviEvent);

        if (!(cursorPos == 0 

           && iFep.IsFlagSet(CAknFepManager::EFlagSupressAutoUpdateAtEditorStart) ))

            {

            TInt defaultCase = editorState->DefaultCase();

            if ( cursorPos == 0 && 

               (defaultCase == EAknEditorLowerCase || defaultCase == EAknEditorUpperCase ))

                {

                SetCurrentCase(defaultCase);

                }

            // UPPER CASE : If in upper case & inside sentence, stay in upper.

            else if (!(iCurrentCase == EAknEditorUpperCase && 

                       CapsLockRequired(cursorPos, iCurrentCase) && 

                       aNaviEvent != EBackspaceEvent))

                {

                const TBool textCaseRequired = TextCaseRequired(cursorPos);

                // UPPER CASE : If upper case & inside sentence & backspace event, stay in upper.

                if (!(iCurrentCase == EAknEditorUpperCase && aNaviEvent == EBackspaceEvent &&

                    !textCaseRequired && cursorPos != 0))

                    {

                    // TEXT CASE : set if at start of editor or following a full stop / text case character

                    if (cursorPos == 0 || textCaseRequired)

                        {

                        TInt inputMode = iFep.InputMode();

                        if (iFep.IsChineseInputLanguage() && 

                        	inputMode != ELatin &&

                        	iCurrentCase != EAknEditorLowerCase)

                        {

                        SetCurrentCase(iCurrentCase);

                        }

#ifdef RD_HINDI_PHONETIC_INPUT	

	                    else if(iFep.IsIndicPhoneticInputLanguage())

	                    	{

	                    	if(CurrentCase() != EAknEditorUpperCase)

	                    	    SetCurrentCase(EAknEditorLowerCase);	

	                    	}

#endif

                        else

                        {

                        /* Teleca change begin, 27.08.2008 ssal 

                        	original code:

                        SetCurrentCase(EAknEditorTextCase);	*/

                        if(iFep.IsKoreanInputLanguage() && inputMode == EHangul )

                        	{

                        	SetCurrentCase(EAknEditorLowerCase);	

                        	}

                        else

                        	{

                            SetCurrentCase(EAknEditorTextCase);

                            }

                        /* Teleca change end, 27.08.2008 ssal */

                        }

                        applyCaseNeeded = EFalse;

                        }

                    else // OTHERWISE LOWER

                        {

                        SetCurrentCase(EAknEditorLowerCase);

                        applyCaseNeeded = EFalse;

                        }

                    }

                }

            }

        else

            {

            iFep.ClearFlag(CAknFepManager::EFlagSupressAutoUpdateAtEditorStart);

            }

        }

    if (applyCaseNeeded)

        {

        ApplyCase();

        }

    }

void CAknFepCaseManager::ManualCaseUpdate()

    {

    if (!CurrentEditorIsFixedCase())

        {

        if (IsCasePermitted(iCurrentCase)) 

            {

            DoManualCaseUpdate();

            iFep.ClearFlag(CAknFepManager::EFlagSupressAutoUpdate);

            }

        }

    }

void CAknFepCaseManager::RevertCaseChange()

    {

    if (!CurrentEditorIsFixedCase())

        {

        if (IsCasePermitted(iPreviousCase)) 

            {

            SetCurrentCase(iPreviousCase); 

            }

        }

    }

void CAknFepCaseManager::SetCurrentCase(TInt aCase, TBool aOverrideNumericTest)

    {

    if ( ( iFep.InputMode() == ENumber || iFep.InputMode() == ENativeNumber ) && 

        !aOverrideNumericTest)

        {

        if ( iFep.EditorState() && 

            (iFep.EditorState()->NumericKeymap() == EAknEditorConverterNumberModeKeymap) )

            {

            // Converter number mode keymap for '*' key requires upper case 'E'.

            iCurrentCase = EAknEditorUpperCase;

            }

        else

            {

            // Number mode keymappings for '*' -key uses lower case letters (pw).

            iCurrentCase = EAknEditorLowerCase;

            }

        }

    else

        {

        if ( aCase == ECaseInverseText )

            {

            iCurrentCase = ECaseUpper;

            iInverseCase = ETrue;

            }

        else

            {

            iCurrentCase = aCase;

            iInverseCase = EFalse;

            }

        }

    ApplyCase();

    }

TInt CAknFepCaseManager::CurrentCase() const

    {

    return iCurrentCase;

    }

TBool CAknFepCaseManager::IsAbleChangeCase() const

    {

    TBool isable = ETrue;

    CAknEdwinState* editorState = iFep.EditorState();

    if (editorState)

    	{

	    const TInt permittedCases = editorState->PermittedCases();

	    if (permittedCases == EAknEditorUpperCase ||

	        permittedCases == EAknEditorLowerCase )

	        {

	        isable = EFalse;

	        }

	    else if ((editorState->Flags() & EAknEditorFlagForceTransparentFepModes)

	          && iFep.IsChineseInputLanguage())

	        {

	        isable = EFalse;

	        }

	    else if ( editorState->Flags() & EAknEditorFlagFixedCase )

	        {

	        isable = EFalse;

	        }

	    else if (!iFep.InputLanguageSupportsCaseChanges())

	        {

	        isable = EFalse;

	        }

    	}

    else

    	{

    	isable = EFalse;

    	}

    return isable;

    }

CAknFepCaseManager::CAknFepCaseManager(CAknFepManager& aFep) :

    iFep(aFep)

    {

    }

void CAknFepCaseManager::ConstructL()

    {

    // Set text case character set from resource

    TResourceReader reader;

    CCoeEnv::Static()->CreateResourceReaderLC(reader, R_AKNFEP_TEXT_CASE_CHARACTER_SET);

    iTextCaseCharacters=reader.ReadTPtrC();

    // Create PictographInterface

    CCoeControl* control = NULL;

    MAknPictographAnimatorCallBack* callback = NULL;

    iPictoInterface = CAknPictographInterface::NewL(*control,*callback);

    CleanupStack::PopAndDestroy(); // reader*/

    }

TInt CAknFepCaseManager::FindCursorPositionAtCaseCheck(TWesternNaviEvent aNaviEvent)

    {

    TCursorSelection curCursSel;

    iFep.FepAwareTextEditor()->GetCursorSelectionForFep(curCursSel);

    TInt docLength = iFep.FepAwareTextEditor()->DocumentLengthForFep();

    TInt returnedPosition = -1;

    TCursorSelection uncommittedText = iFep.UncommittedText();

    switch (aNaviEvent)

        {

        case ENullNaviEvent:

            if (iFep.IsFlagSet(CAknFepManager::EFlagInsideInlineEditingTransaction))

                {

                returnedPosition = uncommittedText.HigherPos();

                }

            else

                {

                // In case of non-predictive mode, following condition

                // check text is selceted mode or not?

                // In selected mode, character always being inserted

                // anchor position

                if( curCursSel.Length() >0 )

                    {

                    returnedPosition = curCursSel.LowerPos();

                    }

                else

                    {

                    returnedPosition = curCursSel.HigherPos();

                    }

                }

            break;

        case ERightNaviEvent:

            if (iFep.IsFlagSet(CAknFepManager::EFlagInsideInlineEditingTransaction))

                {

                returnedPosition = uncommittedText.HigherPos();

                }

            else

                {

                if (curCursSel.Length())

                    {

                    returnedPosition = curCursSel.HigherPos();

                    }

                else

                    {

                    if (curCursSel.iCursorPos == docLength)

                        {

                        returnedPosition = 0;

                        }

                    else

                        {

                        returnedPosition = curCursSel.HigherPos() + 1;

                        }

                    }

                }

            break;

        case ELeftNaviEvent:

            if (iFep.IsFlagSet(CAknFepManager::EFlagInsideInlineEditingTransaction))

                {

                returnedPosition = uncommittedText.LowerPos();

                }

            else

                {

                if (curCursSel.Length())

                    {

                    returnedPosition = curCursSel.LowerPos();

                    }

                else

                    {

                    if (curCursSel.iCursorPos == 0)

                        {

                        returnedPosition = docLength;

                        }

                    else

                        {

                        returnedPosition = curCursSel.LowerPos() - 1;

                        }

                    }

                }

            break;

        case EBackspaceEvent:

            if (iFep.IsFlagSet(CAknFepManager::EFlagInsideInlineEditingTransaction))

                {

                returnedPosition = uncommittedText.HigherPos();

                }

            else

                {

                if (curCursSel.Length())

                    {

                    returnedPosition = curCursSel.LowerPos();

                    }

                else

                    {

                    returnedPosition = curCursSel.LowerPos() - 1;

                    }

                }

            break;

        default:

            break;

        }

    if (returnedPosition < 0)

        {

        returnedPosition = 0;

        }

    else if (returnedPosition > docLength)

        {

        returnedPosition = docLength;

        }