--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/kernel/eka/ewsrv/ky_tran.cpp	Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,696 @@
+// 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);		
+    }
+