/*
* Copyright (c) 2003-2006 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:   PtiKeyMappings class implementation.
*
*/


#include "PtiKeyMappings.h"
#include <PtiKeyMapData.h>

// CONSTANTS
#ifdef _DEBUG
_LIT(KPtiNoKeyMapDataPanic, "PtiEngine: No ITU-T keymap data set.");
#endif

//
// CPtiMappings
//

// ---------------------------------------------------------------------------
// CPtiMappings::CPtiMappings
// 
// ---------------------------------------------------------------------------
// 
CPtiMappings::CPtiMappings()
	{
	}
	
	
// ---------------------------------------------------------------------------
// CPtiMappings::CPtiMappings
// 
// ---------------------------------------------------------------------------
// 	
CPtiMappings::CPtiMappings(CPtiKeyMapData* aData) : iKeyMapData(aData)
	{	
	}


// ---------------------------------------------------------------------------
// CPtiMappings::~CPtiMappings
// 
// ---------------------------------------------------------------------------
// 
CPtiMappings::~CPtiMappings()
	{
	iReplacedMappings.Close();
	}


// ---------------------------------------------------------------------------
// CPtiMappings::FindReplacedMapping
// 
// ---------------------------------------------------------------------------
// 
TInt CPtiMappings::FindReplacedMapping(TPtiKey aKey, TPtiTextCase aCase,
                                       TPtiEngineInputMode aMode) const
	{
	for (TInt i = 0; i < iReplacedMappings.Count(); i++)
		{
		if (iReplacedMappings[i].iKey == aKey &&
		    iReplacedMappings[i].iCase == aCase &&
		    iReplacedMappings[i].iMode == aMode &&
		    iReplacedMappings[i].iKeyboardType == iKeyboardType)
			{
			return i;
			}		
		}
		
	return KErrNotFound;
	}


// ---------------------------------------------------------------------------
// CPtiMappings::ReplaceKeyMapLocalL
// 
// ---------------------------------------------------------------------------
// 
void CPtiMappings::ReplaceKeyMapLocalL(TPtiKey aKey, TDesC& aMap, 
                                       TPtiTextCase aCase, TPtiEngineInputMode aMode)
	{
	TInt i = FindReplacedMapping(aKey, aCase, aMode);
	if (i != KErrNotFound)	
		{
		iReplacedMappings.Remove(i);
		}
	
	TPtiReplacedMapping newMapping;
	newMapping.iKey = aKey;
	newMapping.iCase = aCase;
	newMapping.iMode = aMode;
	newMapping.iKeyboardType = iKeyboardType;
	
	for (i = 0; i < KMaxReplacedMappingCharacters && i < aMap.Length(); i++)	
		{
		newMapping.iChrs[i] = aMap[i];
		}
	newMapping.iNumChars = i;	
		
	User::LeaveIfError(iReplacedMappings.Append(newMapping));	
	}



// ---------------------------------------------------------------------------
// CPtiMappings::DataForKeyLocal
// 
// ---------------------------------------------------------------------------
// 	
TPtrC CPtiMappings::DataForKeyLocal(TPtiKey aKey, TPtiTextCase aCase, TPtiEngineInputMode aMode) const
	{
	__ASSERT_DEBUG(iKeyMapData, User::Panic(KPtiNoKeyMapDataPanic, KErrCorrupt));
		
	if ((aCase == EPtiCaseChrLower) && (iKeyboardType != EPtiKeyboardHalfQwerty))
		{
		aCase = EPtiCaseLower;		
		}
	else if ((aCase == EPtiCaseChrUpper) && (iKeyboardType != EPtiKeyboardHalfQwerty))
		{
		aCase = EPtiCaseUpper;		
		}
				
	TInt replaced = FindReplacedMapping(aKey, aCase, aMode);
	if (replaced != KErrNotFound)
		{		
		if (iReplacedMappings[replaced].iNumChars > 0)		
			{
			return TPtrC(iReplacedMappings[replaced].iChrs,
			             iReplacedMappings[replaced].iNumChars);  
			}
		return TPtrC();	
		}
	
    return iKeyMapData->DataForKey(iKeyboardType, aKey, aCase);	
	}	


// ---------------------------------------------------------------------------
// CPtiMappings::WriteData (DEPRECATED)
// 
// ---------------------------------------------------------------------------
// 	
TInt CPtiMappings::WriteData(TInt16*)   
	{
	return 0;
	}


// ---------------------------------------------------------------------------
// CPtiMappings::ChunkDataSize (DEPRECATED)
// 
// ---------------------------------------------------------------------------
// 	
TInt CPtiMappings::ChunkDataSize() const
	{
	return 0;		
	}


// ---------------------------------------------------------------------------
// CPtiMappings::KeyboardType
// 
// ---------------------------------------------------------------------------
//
EXPORT_C TPtiKeyboardType CPtiMappings::KeyboardType() const
    {
    return iKeyboardType;
    }	


//
// CPtiKeyMappings
//

// ---------------------------------------------------------------------------
// CPtiKeyMappings::NewL
// 
// ---------------------------------------------------------------------------
//
EXPORT_C CPtiKeyMappings* CPtiKeyMappings::NewL(TDesC& /*aData*/)
	{
	// DEPRECATED
	User::Leave(KErrNotSupported);
	return NULL;	
	}


// ---------------------------------------------------------------------------
// CPtiKeyMappings::NewL
// 
// ---------------------------------------------------------------------------
//
EXPORT_C CPtiKeyMappings* CPtiKeyMappings::NewL(TInt16* /*aData*/)
	{
	// DEPRECATED
	User::Leave(KErrNotSupported);
	return NULL;
	}


// ---------------------------------------------------------------------------
// CPtiKeyMappings::NewL
// 
// ---------------------------------------------------------------------------
//
EXPORT_C CPtiKeyMappings* CPtiKeyMappings::NewL(CPtiKeyMapData* aData)
	{
	CPtiKeyMappings* maps = new (ELeave) CPtiKeyMappings(aData);
	return maps; 	
	}
		

// ---------------------------------------------------------------------------
// CPtiKeyMappings::CPtiKeyMappings
// 
// ---------------------------------------------------------------------------
//
CPtiKeyMappings::CPtiKeyMappings()
	{
    iKeyboardType = EPtiKeyboard12Key;      
	}


// ---------------------------------------------------------------------------
// CPtiKeyMappings::CPtiKeyMappings
// 
// ---------------------------------------------------------------------------
//
CPtiKeyMappings::CPtiKeyMappings(CPtiKeyMapData* aData) : CPtiMappings(aData)
	{
    iKeyboardType = EPtiKeyboard12Key; 		
	}


// ---------------------------------------------------------------------------
// CPtiKeyMappings::~CPtiKeyMappings
// 
// ---------------------------------------------------------------------------
//
EXPORT_C CPtiKeyMappings::~CPtiKeyMappings()
	{
	}


// ---------------------------------------------------------------------------
// CPtiKeyMappings::StartMapping
// 
// ---------------------------------------------------------------------------
//
EXPORT_C TUint16 CPtiKeyMappings::StartMapping(TPtiKey aKey, TPtiTextCase aCase,
                                               TPtiEngineInputMode aMode)
	{
	__ASSERT_DEBUG(iKeyMapData, User::Panic(KPtiNoKeyMapDataPanic, KErrCorrupt));
	
	DeQwertyfyCaseValue(aCase);
	
	KeyCodeToInternal(aKey);

    iCurrentMode = aMode;
	iCurrentChar = 0;
    
	TPtrC keyData = DataForKeyLocal(aKey, aCase, iCurrentMode);	
	if (keyData.Length() > 0)
	    {
	    return keyData[0];	
	    }        
	           			
	return 0;
	}  


// ---------------------------------------------------------------------------
// CPtiKeyMappings::NextChar
// 
// ---------------------------------------------------------------------------
//
TUint16 CPtiKeyMappings::NextChar(TPtiTextCase aCase)
	{
	__ASSERT_DEBUG(iKeyMapData, User::Panic(KPtiNoKeyMapDataPanic, KErrCorrupt));
	
	iCurrentChar++;
	
	DeQwertyfyCaseValue(aCase);
		
	TPtrC keyData = DataForKeyLocal(iCurrentKey, aCase, iCurrentMode);
	if (iCurrentChar >= keyData.Length())
		{
		iCurrentChar = 0;
		}
	
	if (keyData.Length())
		{
		return keyData[iCurrentChar];
		}

	return 0;	
	}


// ---------------------------------------------------------------------------
// CPtiKeyMappings::ReplaceKeyMapL
// 
// ---------------------------------------------------------------------------
//
EXPORT_C TInt CPtiKeyMappings::ReplaceKeyMapL(TPtiKey aKey, TDesC& aMap,
                                              TPtiTextCase aCase)                                                                                            
	{
	if (iCurrentKey == aKey)
		{		
		iCurrentKey = EPtiKeyNone;
		iCurrentChar = 0;
		}	
		
	DeQwertyfyCaseValue(aCase);		
	
	ReplaceKeyMapLocalL(aKey, aMap, aCase, EPtiEngineMultitapping);
	
	return KErrNone;
	}


// ---------------------------------------------------------------------------
// CPtiKeyMappings::NextKey
// 
// ---------------------------------------------------------------------------
//	
EXPORT_C TUint16 CPtiKeyMappings::NextKey(TPtiKey aKey, TBool &aAppend,
                                          TPtiTextCase aCase)
	{
	if (CurrentKey() == aKey)
		{
		aAppend = EFalse;
		return NextChar(aCase);	
		}

	return StartMapping(aKey, aCase);
	}


// ---------------------------------------------------------------------------
// CPtiKeyMappings::KeyForCharacter
// 
// ---------------------------------------------------------------------------
//
EXPORT_C TPtiKey CPtiKeyMappings::KeyForCharacter(TUint16 aChar)
	{
	__ASSERT_DEBUG(iKeyMapData, User::Panic(KPtiNoKeyMapDataPanic, KErrCorrupt));
	
	TInt numBindItems = 0;
	const TPtiKeyBinding* bindings = iKeyMapData->KeyBindingTable(iKeyboardType, numBindItems);
    TInt dataSize = 0;
	const TUint16* mtData = iKeyMapData->KeyData(iKeyboardType, dataSize);  
	
	TPtiTextCase textCase;
	TPtiKey key;
	for (TInt i = 0; i < numBindItems; i++)
		{
		key = iKeyMapData->KeyForBindingTableIndex(iKeyboardType, i, textCase);
		if (key != EPtiKeyNone)
			{
			TPtrC keyData = DataForKeyLocal(key, textCase, EPtiEngineMultitapping);
			if (keyData.Locate(aChar) != KErrNotFound)
				{
				return key;
				}			
			}
		}
			 
	return EPtiKeyNone;	
	}


// ---------------------------------------------------------------------------
// CPtiKeyMappings::GetDataForKey
// 
// ---------------------------------------------------------------------------
//
EXPORT_C void CPtiKeyMappings::GetDataForKey(TPtiKey aKey, TDes& aResult, 
                                             TPtiTextCase aCase)
	{
	__ASSERT_DEBUG(iKeyMapData, User::Panic(KPtiNoKeyMapDataPanic, KErrCorrupt));

	DeQwertyfyCaseValue(aCase);

	aResult.Copy(DataForKeyLocal(aKey, aCase, EPtiEngineMultitapping).Left(aResult.MaxLength()));	
	}


// ---------------------------------------------------------------------------
// CPtiKeyMappings::GetAll
// 
// ---------------------------------------------------------------------------
//
TPtrC CPtiKeyMappings::GetAll(TPtiTextCase aCase)
	{
	__ASSERT_DEBUG(iKeyMapData, User::Panic(KPtiNoKeyMapDataPanic, KErrCorrupt));
	
	DeQwertyfyCaseValue(aCase);	
	
	TPtrC keyData = DataForKeyLocal(iCurrentKey, aCase, EPtiEngineMultitapping);	
	if (keyData.Length() > 1)	
		{
		// Return characters excluding the control char.
		return keyData.Mid(1);		
		}
	
	return TPtrC();	
	}
	
//
// CPtiHalfQwertyKeyMappings
// 

// ---------------------------------------------------------------------------
// CPtiHalfQwertyKeyMappings::NewL
// 
// ---------------------------------------------------------------------------
//
EXPORT_C CPtiHalfQwertyKeyMappings* CPtiHalfQwertyKeyMappings::NewL(CPtiKeyMapData* aData)
    {
    CPtiHalfQwertyKeyMappings* maps = new (ELeave) CPtiHalfQwertyKeyMappings(aData);
	return maps;  
    }


// ---------------------------------------------------------------------------
// CPtiHalfQwertyKeyMappings::::CPtiHalfQwertyKeyMappings
// 
// ---------------------------------------------------------------------------
//
CPtiHalfQwertyKeyMappings::CPtiHalfQwertyKeyMappings(CPtiKeyMapData* aData) : CPtiKeyMappings(aData)
    { 
    iKeyboardType = EPtiKeyboardHalfQwerty;      
    }


// ---------------------------------------------------------------------------
// CPtiHalfQwertyKeyMappings::~CPtiHalfQwertyKeyMappings
// 
// ---------------------------------------------------------------------------
//	    
EXPORT_C CPtiHalfQwertyKeyMappings::~CPtiHalfQwertyKeyMappings()
    {    
    }

// ---------------------------------------------------------------------------
// CPtiHalfQwertyKeyMappings::StartMapping
// 
// ---------------------------------------------------------------------------
//
EXPORT_C TUint16 CPtiHalfQwertyKeyMappings::StartMapping(TPtiKey aKey, TPtiTextCase aCase,
                                               TPtiEngineInputMode aMode)
	{
	__ASSERT_DEBUG(iKeyMapData, User::Panic(KPtiNoKeyMapDataPanic, KErrCorrupt));
	
	//DeQwertyfyCaseValue(aCase);
	
	KeyCodeToInternal(aKey);

    iCurrentMode = aMode;
	iCurrentChar = 0;
    
	TPtrC keyData = DataForKeyLocal(aKey, aCase, iCurrentMode);	
	if (keyData.Length() > 0)
	    {
	    return keyData[0];	
	    }        
	    
	           			
	return 0;
	}

// ---------------------------------------------------------------------------
// CPtiHalfQwertyKeyMappings::NextKey
// 
// ---------------------------------------------------------------------------
// 
EXPORT_C TUint16 CPtiHalfQwertyKeyMappings::NextKey(TPtiKey aKey, TBool &aAppend,
                                                TPtiTextCase aCase)
	{
	if (CurrentKey() == aKey)
		{
		aAppend = EFalse;
		return NextChar(aCase);	
		}

	return StartMapping(aKey, aCase);
	}

	
// ---------------------------------------------------------------------------
// TUint16 CPtiHalfQwertyKeyMappings::NextChar(TPtiTextCase aCase)
// 
// ---------------------------------------------------------------------------
//        
TUint16 CPtiHalfQwertyKeyMappings::NextChar(TPtiTextCase aCase)
	{
	__ASSERT_DEBUG(iKeyMapData, User::Panic(KPtiNoKeyMapDataPanic, KErrCorrupt));
	
	iCurrentChar++;
	// we want to retain chr cases in half qwerty
	//DeQwertyfyCaseValue(aCase);
		
	TPtrC keyData = DataForKeyLocal(iCurrentKey, aCase, iCurrentMode);
	if (iCurrentChar >= keyData.Length())
		{
		iCurrentChar = 0;
		}
	
	if (keyData.Length())
		{
		return keyData[iCurrentChar];
		}

	return 0;	
	}
// ---------------------------------------------------------------------------
// CPtiHalfQwertyKeyMappings::ReplaceKeyMapL
// 
// ---------------------------------------------------------------------------
//        
EXPORT_C TInt CPtiHalfQwertyKeyMappings::ReplaceKeyMapL(TPtiKey aKey, TDesC& aMap, TPtiTextCase aCase)
    {
	if (iCurrentKey == aKey)
		{		
		iCurrentKey = EPtiKeyNone;
		iCurrentChar = 0;
		}	
		
//	DeQwertyfyCaseValue(aCase);		
	
	ReplaceKeyMapLocalL(aKey, aMap, aCase, EPtiEngineHalfQwerty);
	
	return KErrNone;        
    }
     
 
// ---------------------------------------------------------------------------
// CPtiHalfQwertyKeyMappings::KeyForCharacter
// 
// ---------------------------------------------------------------------------
//   
EXPORT_C TPtiKey CPtiHalfQwertyKeyMappings::KeyForCharacter(TUint16 aChar)
    {
	__ASSERT_DEBUG(iKeyMapData, User::Panic(KPtiNoKeyMapDataPanic, KErrCorrupt));
	
	TInt numBindItems = 0;
	const TPtiKeyBinding* bindings = iKeyMapData->KeyBindingTable(iKeyboardType, numBindItems);
    TInt dataSize = 0;
	const TUint16* mtData = iKeyMapData->KeyData(iKeyboardType, dataSize);  
	
	TPtiTextCase textCase;
	TPtiKey key;
	for (TInt i = 0; i < numBindItems; i++)
		{
		key = iKeyMapData->KeyForBindingTableIndex(iKeyboardType, i, textCase);
		if (key != EPtiKeyNone)
			{
			TPtrC keyData = DataForKeyLocal(key, textCase, EPtiEngineHalfQwerty);
			if (keyData.Locate(aChar) != KErrNotFound)
				{
				return key;
				}			
			}
		}
			 
	return EPtiKeyNone;	    
    }
    

// ---------------------------------------------------------------------------
// CPtiHalfQwertyKeyMappings::GetAll
// 
// ---------------------------------------------------------------------------
//    
EXPORT_C TPtrC CPtiHalfQwertyKeyMappings::GetAll(TPtiTextCase aCase)
    {
	__ASSERT_DEBUG(iKeyMapData, User::Panic(KPtiNoKeyMapDataPanic, KErrCorrupt));
	
//	DeQwertyfyCaseValue(aCase);	
	
	TPtrC keyData = DataForKeyLocal(iCurrentKey, aCase, EPtiEngineHalfQwerty);	
	if (keyData.Length() > 1)	
		{
		// Return characters excluding the control char.
		return keyData.Mid(1);		
		}
	
	return TPtrC();	    
    }	
    
    
// ---------------------------------------------------------------------------
// CPtiHalfQwertyKeyMappings::GetNumericModeKeysFromDataL
// 
// ---------------------------------------------------------------------------
// 
void CPtiHalfQwertyKeyMappings::GetNumericModeKeysFromDataL(RArray<TPtiNumericKeyBinding>& aResult)
	{
	CleanupClosePushL( aResult );
	__ASSERT_DEBUG(iKeyMapData, User::Panic(KPtiNoKeyMapDataPanic, KErrCorrupt));
	
	TInt numEntries = 0;
	const TPtiNumericKeyBinding* dataEntries = iKeyMapData->NumericModeKeysTable(iKeyboardType, 
	                                                                             numEntries);
	
	for (TInt i = 0; i < numEntries; i++)
		{
		User::LeaveIfError(aResult.Append(dataEntries[i]));
		}
    CleanupStack::Pop();
	}    
	
	
// ---------------------------------------------------------------------------
// CPtiQwertyKeyMappings::GetDataForKey
// 
// ---------------------------------------------------------------------------
// 
EXPORT_C void CPtiHalfQwertyKeyMappings::GetDataForKey(TPtiKey aKey, TDes& aResult,
                                                       TPtiTextCase aCase)
	{
	__ASSERT_DEBUG(iKeyMapData, User::Panic(KPtiNoKeyMapDataPanic, KErrCorrupt));

	aResult.Copy(DataForKeyLocal(aKey, aCase, EPtiEngineHalfQwerty).Left(aResult.MaxLength()));
	}
		

// End of file


