// Copyright (c) 1996-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "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:

// e32\ewsrv\ky_tran.cpp

// The main code for setting modifiers and translating raw scanCodes into

// keyCodes. Also traps capture-keys

// 

//

#include <e32svr.h>

#include <k32keys.h>

#include <e32keys.h>

#include <e32uid.h>

enum	{EDummy,EKeyDataConv,EKeyDataFunc,EKeyDataSettings};

EXPORT_C CKeyTranslator* CKeyTranslator::New()

//

// Return the actual key translator

//

    {

    CKeyTranslatorX* pS=new CKeyTranslatorX;

	if (pS && pS->Initialise()!=KErrNone)

		{

		delete pS;

		pS=NULL;

		}

    return(pS);

    }

CKeyTranslatorX::CKeyTranslatorX()

#pragma warning (disable: 4705)

	{

#pragma warning (default: 4705)

    UpdateModifiers(0);

	}

TInt CKeyTranslatorX::Initialise()

	{

	return (ChangeKeyData(_L("")));	//Set default keydata

	}

TBool CKeyTranslatorX::currentlyUpperCase(void)

//

// Determines whether a letter should be returned as upper case given the

// current state of the modifiers. This is used for accented characters

// created, for example, by entering Ctrl-1 "a". Since the keyboard may be

// configured in different ways (e.g. shift AND capslock together may result

// in either upper or lower case letters), a dynamic function such as this

// is necessary

//

	{

	TInt modifiersAffectingUpperCase=0;

	if (iCurModifiers&EModifierCapsLock)

		modifiersAffectingUpperCase|=EModifierCapsLock;

	if (iCurModifiers&EModifierShift)

		modifiersAffectingUpperCase|=EModifierShift;

	for (TUint i=iConvTable.FirstScanCode(); i<=iConvTable.LastScanCode(); i++)

		{

		TChar ch=iConvTable.Convert(i, modifiersAffectingUpperCase).keyCode;

		if (ch.IsUpper())

			return ETrue;

		else if (ch.IsLower())

			return EFalse;

		}

	return EFalse;

	}

TUint CKeyTranslatorX::executeFunctionsAndSetState(TCharExtended aChar)

//

// Looks up and carries out the function required for the given

// key-code/modifiers/state

//

	{

	TUint keyCode=EKeyNull;

	SFunc modifierFunc=iFuncTable.GetModifierFunc(aChar, iCurModifiers);

	SFuncAndState genFuncAndNewState=iFuncTable.GetGeneralFuncAndState(aChar, iCurModifiers, iCurState,

																			iCurCtrlDigits.GetRadix());

    SetModifierState((TEventModifier)modifierFunc.funcParam,(TModifierState)modifierFunc.func);

    if(!(iCurModifiers&(EModifierLeftAlt|EModifierRightAlt)))

        iCurModifiers&=~EModifierAlt;

    if(!(iCurModifiers&(EModifierLeftShift|EModifierRightShift)))

        iCurModifiers&=~EModifierShift;

    if(!(iCurModifiers&(EModifierLeftFunc|EModifierRightFunc)))

        iCurModifiers&=~EModifierFunc;

    if(!(iCurModifiers&(EModifierLeftCtrl|EModifierRightCtrl)))

        iCurModifiers&=~EModifierCtrl;

	switch (genFuncAndNewState.func)

		{

	case EDoNothing:

		break;

	case EPassKeyThru:

		keyCode=aChar;

		break;

	case EPassSpecialKeyThru:

		iCurCtrlDigits.Reset();

		keyCode=(currentlyUpperCase())?

					User::UpperCase(genFuncAndNewState.funcParam):

					genFuncAndNewState.funcParam;

		iCurModifiers|=(EModifierSpecial);

		break;

	case EPassCtrlDigitsThru:

		if (iCurCtrlDigits.WithinLimits())

			{

			keyCode=iCurCtrlDigits.GetDigits();

			iCurModifiers|=(EModifierSpecial);

			}

		iCurCtrlDigits.Reset();

		break;

	case EAddOnCtrlDigit:

		iCurCtrlDigits.AppendDigit(aChar, iCurModifiers);

		if (iCurCtrlDigits.Terminated(iCurModifiers) && !iCurCtrlDigits.Error() && iCurCtrlDigits.WithinLimits())

			{

			keyCode=iCurCtrlDigits.GetDigits();

			iCurModifiers|=(EModifierSpecial);

			}

		break;

	}

	switch (genFuncAndNewState.state)

		{

	case EStateUnchanged:

		break;

	case EStateDerivedFromDigitEntered:

		iCurState=aChar.DigitValue();

		break;

	case EStateCtrlDigits:

		if (iCurCtrlDigits.Terminated(iCurModifiers) || iCurCtrlDigits.Error())

	 		{

			iCurState=EStateNormal;

			iCurCtrlDigits.Reset();

			}

		else

			iCurState=iCurCtrlDigits.SetStateToCtrlDigits();

		break;

	default:

		iCurState=genFuncAndNewState.state;

		if (iCurState==EStateNormal)

			iCurCtrlDigits.Reset();

		break;

		}

	return keyCode;

	}

TInt CKeyTranslatorX::GetModifierState()

//

// Return the current modifier state

//

    {

    return(iCurModifiers);

    }

void CKeyTranslatorX::UpdateModifiers(TInt aModifiers)

//

//

//

    {

    if(aModifiers == EModifierCancelRotation || aModifiers & KRotationModifiers)

        iCurModifiers &= KPersistentModifiers;	// if a Rotation modifier is being updated, only keep persistent modifiers

	else

	    iCurModifiers &= KPersistentModifiers|KRotationModifiers;		// if not, keep Rotation modifiers also

	iCurModifiers |= aModifiers;

    iCurState = EStateNormal;

    }

void CKeyTranslatorX::SetModifierState(TEventModifier aModifier,TModifierState aState)

//

// Change a modifier state

//

    {

    switch(aState)

        {

        case ETurnOffModifier:

            iCurModifiers&=~aModifier;

            break;

        case ETurnOnModifier:

            iCurModifiers|=aModifier;

            break;

        case EToggleModifier:

            iCurModifiers^=aModifier;

        }

    }

TBool CKeyTranslatorX::TranslateKey(TUint aScanCode, TBool aKeyUp,

											const CCaptureKeys &aCaptureKeys, TKeyData &aKeyData)

//

// The function called for every keyup/keydown converting the aScanCode into a

// keyCode, carrying out the function specified in the keyboard configuration

// tables and setting the new state of the keyboard

//

	{

#if defined(__WINS__)

	// This code extracts the character code if there is one munged

	// with the scan code.  Code which does not take advantage of this

	// new facility to pass a character code as part of aScanCode should

	// be unaffected

	// 

	// extract the character code

	TUint charCode=(aScanCode&0xFFFF0000)>>16;

	// extract the scan code

	aScanCode&=0x0000FFFF;

#endif

	TUint oldState=iCurState;

   	TCharExtended ch;

    iCurModifiers&=~(EModifierPureKeycode);

    if(aScanCode<ESpecialKeyBase || aScanCode>=(ESpecialKeyBase+ESpecialKeyCount))

        {

    	SConvKeyData convKeyData=(iCurState==EStateNormal)?

					iConvTable.Convert(aScanCode, iCurModifiers):

					iConvTable.ConvertBaseCase(aScanCode, iCurModifiers);

    	TMaskedModifiers convModifiers;

    	convModifiers.iMask=KConvTableSettableModifiers;

    	convModifiers.iValue=convKeyData.modifiers;

    	MergeModifiers(iCurModifiers,convModifiers);

        ch=convKeyData.keyCode;

        }

    else

        ch=aScanCode;

 	if (aKeyUp)

		iCurModifiers|=(EModifierKeyUp);

	else

		iCurModifiers&=~(EModifierKeyUp);

	aKeyData.iKeyCode=executeFunctionsAndSetState(ch);

    ch=aKeyData.iKeyCode;

    // prevent modifier keys returning as keypresses

    if(ch.IsModifier())

        {

        aKeyData.iKeyCode=EKeyNull;

        iCurModifiers&=~EModifierPureKeycode;

        }

	TBool ret;

	ret=(aKeyData.iKeyCode!=EKeyNull);

#if defined(__WINS__)

	// see comments in __WINS__ block above

	if (charCode)

		{

        if (!(iCurModifiers & KRotationModifiers)) // if rotation modifiers not set we trust the WINDOWS translation

            {

		    aKeyData.iKeyCode=charCode;

		    iCurModifiers|=EModifierAutorepeatable;

            }

        ret = ETrue;

		}

#endif

	if (aKeyUp

		|| (aKeyData.iKeyCode==EKeyNull)

		|| (iCurState!=EStateNormal)

		|| (iCurState!=oldState))

		{

		iCurModifiers&=~(EModifierAutorepeatable);

		}

    // convert ctrl-space to EKeyNull and clear PureKeycode modifier

    if(aKeyData.iKeyCode==EKeySpace && iCurModifiers&EModifierCtrl)

        {

        aKeyData.iKeyCode=EKeyNull;

        iCurModifiers&=~EModifierPureKeycode;

        }

    aKeyData.iModifiers=iCurModifiers;

    iCurModifiers&=(KPersistentModifiers|KRotationModifiers); // only keep persistent and rotation modifiers

#if defined(__WINS__)

	if (ret)

        {

        if (charCode && (iCurModifiers & KRotationModifiers))

            {

            TKeyData keyData = aKeyData;

            keyData.iKeyCode = charCode;

            aCaptureKeys.ProcessCaptureKeys(keyData);

			// Pass the key capture data to the argument

			aKeyData.iApp = keyData.iApp;

			aKeyData.iHandle = keyData.iHandle;

			aKeyData.iIsCaptureKey = keyData.iIsCaptureKey;

            }

        else

            aCaptureKeys.ProcessCaptureKeys(aKeyData);

        }

#else

	if (ret)

		aCaptureKeys.ProcessCaptureKeys(aKeyData);

#endif

	return(ret);

	}

//

// A miscellaneous collection of classes used in key translation

//

TCharExtended &TCharExtended::operator=(TUint aChar)

	{

	SetChar(aChar);

	return *this;

	}

//

TBool TCharExtended::IsDigitGivenRadix(TRadix aRadix) const

// Returns true if the character is a digit given the aRadix

	{

	switch (aRadix)

		{

	case EBinary:

		return (TBool)((TUint(*this)==(TUint)'0') || (TUint(*this)==(TUint)'1'));

	case EOctal:

		return (TBool)(IsDigit() && (TUint(*this)!=(TUint)'8') && (TUint(*this)!=(TUint)'9'));

	case EDecimal:

		return IsDigit();

	case EHex:

		return IsHexDigit();

	default:

		return EFalse;

		}

	}

//

TBool TCharExtended::IsModifier() const

	{

	switch ((TUint)(*this))

		{

		case EKeyLeftShift:

		case EKeyLeftFunc:

		case EKeyLeftCtrl:

		case EKeyLeftAlt:

		case EKeyRightShift:

		case EKeyRightFunc:

		case EKeyRightCtrl:

		case EKeyRightAlt:

		case EKeyCapsLock:

		case EKeyNumLock:

		case EKeyScrollLock:

		case EKeyKeyboardExtend:

			return ETrue;

		default:

			return EFalse;

		}

	}

//

TInt TCharExtended::DigitValue() const

// Return the numeric value of the character if it is a digit, otherwise an errorcode

	{

	if (IsDigit())

		return (TInt(*this))-48;

	else if ((TInt(*this)>='A') && (TUint(*this)<='F'))

		return (TInt(*this))+10-'A';

	else if ((TInt(*this)>='a') && (TUint(*this)<='f'))

		return (TInt(*this))+10-'a';

	else

		return KErrArgument;

	}

//

TBool TCharExtended::MatchesPattern(const TKeyCodePattern &aKeyCodePattern, TRadix aRadix) const

// Return true if the character matches the given pattern

	{

	switch (aKeyCodePattern.iPattern)

		{

	case EAnyKey:

		return ETrue;

	case EAnyAlphaNumeric:

		return IsAlphaDigit();

	case EAnyAlpha:

		return IsAlpha();

	case EAnyAlphaLowerCase:

		return IsLower();

	case EAnyAlphaUpperCase:

		return IsUpper();

	case EAnyDecimalDigit:

		return IsDigit();

	case EAnyDigitGivenRadix:

		return IsDigitGivenRadix(aRadix);

	case EAnyModifierKey:

		return IsModifier();

    case EMatchLeftOrRight:

        return (TBool)(TUint(*this)==aKeyCodePattern.iKeyCode || TUint(*this)==(aKeyCodePattern.iKeyCode+(TUint)1));

	case EMatchKey:

		return (TBool)(TUint(*this)==aKeyCodePattern.iKeyCode);

	case EMatchKeyCaseInsens:

		return (TBool)(User::LowerCase((TUint)*this)==User::LowerCase(aKeyCodePattern.iKeyCode));

	default:

		return EFalse;

		}

	}

//

typedef void (*TLibFnDataSetting)(TRadix &aRadix,TCtrlDigitsTermination &aCtrlDigitsTermination,TInt &aDefaultCtrlDigitsMaxCount,

							      TInt &aMaximumCtrlDigitsMaxCount);

void TCtrlDigits::Update(RLibrary aLibrary)

	{

	((TLibFnDataSetting)aLibrary.Lookup(EKeyDataSettings))(iRadix,iTermination,iMaxCount,iMaximumCtrlDigitsMaxCount);

	iCount=0;

	iErrorFlag=EFalse;

	iDigits=0L;

	};

//

TCtrlDigits::TCtrlDigits()

	{

	};

//

void TCtrlDigits::Reset()

// Reset to 0

	{

	iCount=0;

	iErrorFlag=EFalse;

	iDigits=0L;

	};

//

void TCtrlDigits::AppendDigit(TUint aKeyCode, TUint aModifiers)

// Append the given digit to the current digits

	{

	TCharExtended ch=aKeyCode;

	iCount++;

	iDigits*=iRadix;

	iDigits+=ch.DigitValue();

	iErrorFlag=(TBool)(iErrorFlag

					  || !ch.IsDigitGivenRadix(iRadix)

					  || (iTermination==ETerminationByCtrlUp)

						  && ((aModifiers&EModifierCtrl)==0));

	}

//

TBool TCtrlDigits::Terminated(TInt aModifiers) const

// Return true if the digits have been terminated and are ready to return as a keyCode

	{

	return (TBool)( ((iTermination==ETerminationByCount) && (iCount>=iMaxCount))

				 || ((iTermination==ETerminationByCtrlUp) && (aModifiers&EModifierCtrl)==0)

                 || (iCount>=iMaximumCtrlDigitsMaxCount) );

	}

//

TUint TCtrlDigits::SetStateToCtrlDigits() const

// Return either "EStateCtrlDigitsUntilCount" or "EStateCtrlDigitsUntilCtrlUp"

// according to the current termination type

	{

	switch (iTermination)

		{

	case ETerminationByCount:

		return EStateCtrlDigitsUntilCount;

	case ETerminationByCtrlUp:

		return EStateCtrlDigitsUntilCtrlUp;

	default:

		return EStateNormal;

		}

	}

//

// Two classes that provide operations for accessing the keyboard configuration tables

//

typedef void (*TLibFnDataConv)(SConvTable &aConvTable, TUint &aConvTableFirstScanCode,TUint &aConvTableLastScanCode,

							   SScanCodeBlockList &aKeypadScanCode,SKeyCodeList &aNonAutorepKeyCodes);

//

void TConvTable::Update(RLibrary aLibrary)

#pragma warning (disable: 4705)

	{

#pragma warning (default: 4705)

	((TLibFnDataConv)aLibrary.Lookup(EKeyDataConv))(iConvTable,iFirstScanCode,iLastScanCode,iKeypadScanCodes,iNonAutorepKeyCodes);

	}

//

//

TConvTable::TConvTable()

#pragma warning (disable: 4705)

	{

#pragma warning (default: 4705)

	}

//

TBool TConvTable::onKeypad(TUint aScanCode) const

// Return True if the given aScanCode is on the keypad

	{

	for (TUint i=0; i<iKeypadScanCodes.numBlocks; i++)

		if ((aScanCode>=iKeypadScanCodes.pblocks[i].firstScanCode)

			&& (aScanCode<=iKeypadScanCodes.pblocks[i].lastScanCode))

			{

			return ETrue;

			}

	return EFalse;

	}

//

TBool TConvTable::autorepeatable(TUint aKeyCode) const

// Return True if the given aKeyCode is autorepeatable

	{

	for (TUint i=0; i<iNonAutorepKeyCodes.numKeyCodes; i++)

		if (aKeyCode==iNonAutorepKeyCodes.pkeyCodes[i])

			return EFalse;

	return ETrue;

	}

//

SConvKeyData TConvTable::Convert(TUint aScanCode, const TInt &aModifiers) const

// Convert the given aScanCode and aModifiers into a keyCode and aModifiers

	{

	SConvKeyData returnVal;

	returnVal.keyCode=EKeyNull;

	returnVal.modifiers=0;

	for (TUint i=0; i<iConvTable.numNodes; i++)

        {

		if (MatchesMaskedValue(aModifiers,iConvTable.pnodes[i].maskedModifiers))

            {

			for (TUint j=0; j<iConvTable.pnodes[i].numSubTables; j++)

				{

				TUint offset=0;

				for (TUint k=0; k<iConvTable.pnodes[i].ppsubTables[j]->scanCodes.numBlocks; k++)

                    {

					if ((aScanCode>=iConvTable.pnodes[i].ppsubTables[j]->scanCodes.pblocks[k].firstScanCode) &&

						(aScanCode<=iConvTable.pnodes[i].ppsubTables[j]->scanCodes.pblocks[k].lastScanCode))

						{

						returnVal.keyCode=iConvTable.pnodes[i].ppsubTables[j]->pkeyCode[offset+

										(aScanCode-iConvTable.pnodes[i].ppsubTables[j]->scanCodes.pblocks[k].firstScanCode)];

						if (onKeypad(aScanCode))

							returnVal.modifiers|=(EModifierKeypad);

						if (autorepeatable(returnVal.keyCode))

							returnVal.modifiers|=(EModifierAutorepeatable);

                        // check if ctrl key pressed and keycode has not been modified due to ctrl key

                        if (aModifiers&EModifierCtrl && !(iConvTable.pnodes[i].maskedModifiers.iMask&EModifierCtrl))

                            returnVal.modifiers|=(EModifierPureKeycode);

						return returnVal;

						}

					else

						offset+=iConvTable.pnodes[i].ppsubTables[j]->scanCodes.pblocks[k].lastScanCode-

								iConvTable.pnodes[i].ppsubTables[j]->scanCodes.pblocks[k].firstScanCode+1;

                    }

				}

            }

        }

	return returnVal;

	}

//

SConvKeyData TConvTable::ConvertBaseCase(TUint aScanCode, const TInt &aModifiers) const

// As TConvTable::Convert above, except that all input aModifiers are ignored except for EModifierNumlock

	{

	if (aModifiers&EModifierNumLock)

		return Convert(aScanCode, EModifierNumLock);

	else

		return Convert(aScanCode, 0);

	}

typedef void (*TLibFnDataFunc)(SFuncTables &aFuncTables);

void TFuncTable::Update(RLibrary aLibrary)

#pragma warning (disable: 4705)

	{

#pragma warning (default: 4705)

	((TLibFnDataFunc)aLibrary.Lookup(EKeyDataFunc))(iFuncTables);

	}

//

TFuncTable::TFuncTable()

#pragma warning (disable: 4705)

	{

#pragma warning (default: 4705)

	}

//

SFuncTableEntry TFuncTable::getDefault(const TCharExtended &aChar, const TInt &aModifiers) const

// Get the default table entry. Should be called if passing through a normal function-table did

// not trap these parameters.

	{

    TUint i=0;

	while(i<iFuncTables.defaultTable.numEntries)

        {

		if (aChar.MatchesPattern(iFuncTables.defaultTable.pentries[i].keyCodePattern)

			&& MatchesMaskedValue(aModifiers,iFuncTables.defaultTable.pentries[i].maskedModifiers))

			{

		   	break;

			}

        i++;

        }

   	return iFuncTables.defaultTable.pentries[i];

	}

SFunc TFuncTable::GetModifierFunc(const TCharExtended &aChar, const TInt &aModifiers) const

// Pass through the modifier table, returning the first table entry matching the given parameters.

	{

	SFuncTableEntry defaultTableEntry=getDefault(aChar, aModifiers);

	SFunc returnVal = { 0, 0, 0 };

	returnVal.func=defaultTableEntry.funcAndNewState.func;

	returnVal.funcParam=defaultTableEntry.funcAndNewState.funcParam;

	for (TUint i=0; i<iFuncTables.modifierTable.numEntries; i++)

		if (aChar.MatchesPattern(iFuncTables.modifierTable.pentries[i].keyCodePattern)

			&& MatchesMaskedValue(aModifiers,iFuncTables.modifierTable.pentries[i].maskedModifiers))

			{

			returnVal.func=iFuncTables.modifierTable.pentries[i].funcAndNewState.func;

			returnVal.funcParam=iFuncTables.modifierTable.pentries[i].funcAndNewState.funcParam;

		   	return returnVal;

			}

   	return returnVal;

	}

SFuncAndState TFuncTable::GetGeneralFuncAndState(const TCharExtended &aChar, const TInt &aModifiers,

																		TUint aCurState, TRadix aRadix) const

// Pass through the table corresponding to the current keyboard state, returning the first

// table entry matching the given parameters.

	{

	for (TUint i=0; i<iFuncTables.pgenFuncTables[aCurState].numEntries; i++)

		if (aChar.MatchesPattern(iFuncTables.pgenFuncTables[aCurState].pentries[i].keyCodePattern, aRadix)

			&& MatchesMaskedValue(aModifiers,iFuncTables.pgenFuncTables[aCurState].pentries[i].maskedModifiers))

			{

			return iFuncTables.pgenFuncTables[aCurState].pentries[i].funcAndNewState;

			}

   	return getDefault(aChar, aModifiers).funcAndNewState;

	}

TInt CKeyTranslatorX::ChangeKeyData(const TDesC& aLibName)

//

// change keydata

//

    {	

	if(aLibName.Length()==0) // Back to default KeyData

		{

		if (!iIsdefaultKeyData)

			{

			_LIT(KEkData,"EKDATA.DLL");

			TInt r=iDefaultKeyDataLib.Load(KEkData);

			if (r!=KErrNone && r!=KErrAlreadyExists)

				return r;

			// Check for valid KeyboardData dll type

			if(iDefaultKeyDataLib.Type()[2]!=KKeyboardDataUid) 

				{	

				iDefaultKeyDataLib.Close();

				return(KErrCorrupt);//Only due to bad rom.

				}

			iConvTable.Update(iDefaultKeyDataLib);

			iCurCtrlDigits.Update(iDefaultKeyDataLib);

			iFuncTable.Update(iDefaultKeyDataLib);

			iIsdefaultKeyData = ETrue;						// EKeyData status	 

			iKeyDataLib.Close();							// Close previously loaded keydata

			}

		return(KErrNone);		

		}

//	

	RLibrary lib;

	TInt res=lib.Load(aLibName); 

	if (res!=KErrNone && res!=KErrAlreadyExists)

		return(res);

//

// Check for valid KeyboardData dll type

//

	if(lib.Type()[2]!=KKeyboardDataUid) 

		{	

		lib.Close();

		return(KErrArgument);

		}

	// Close previously loaded keydata

	if (iIsdefaultKeyData)

		{

		iIsdefaultKeyData = EFalse;							// EKeyData status

		iDefaultKeyDataLib.Close();

		}

    else

		iKeyDataLib.Close();

	iKeyDataLib=lib;

	iConvTable.Update(lib);

	iCurCtrlDigits.Update(lib);

	iFuncTable.Update(lib);

	return(KErrNone);		

    }