/*

* Copyright (c) 2003-2007 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:   PtiLanguage class implementation.

*

*/

#include "PtiKeyMappings.h"

#include "PtiLanguage.h"

#include <PtiKeyMapData.h>

#include <PtiCore.h>

#include "PtiDefaultCore.h"

#ifdef _DEBUG

_LIT(KPtiEngineLangPanic, "CPtiLanguage");

#endif

//

// TPtiKeyMappingsHolder

//

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

// TPtiKeyMappingsHolder::TPtiKeyMappingsHolder

// 

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

// 

TPtiKeyMappingsHolder::TPtiKeyMappingsHolder()

    {

    iKeyMappings = NULL;

    iQwertyKeyMappings = NULL;

    iHalfQwertyMappings = NULL;       

    }

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

// TPtiKeyMappingsHolder::~TPtiKeyMappingsHolder

// 

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

//     

TPtiKeyMappingsHolder::~TPtiKeyMappingsHolder()

    {

    Clear();

    }

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

// TPtiKeyMappingsHolder::´Clear()

// 

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

//         

void TPtiKeyMappingsHolder::Clear()

    {

    delete iKeyMappings;

    iKeyMappings = NULL;

    delete iQwertyKeyMappings;

    iQwertyKeyMappings = NULL;

    delete iHalfQwertyMappings;          

    iHalfQwertyMappings = NULL;

    }

//

// CPtiCoreLanguage

//

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

// CPtiCoreLanguage::NewL

// 

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

// 

EXPORT_C CPtiCoreLanguage* CPtiCoreLanguage::NewL()

	{

	CPtiCoreLanguage* lang = new (ELeave) CPtiCoreLanguage();

	CleanupStack::PushL( lang );

	lang->ConstructL();

	CleanupStack::Pop(); // lang

	return lang;

	}

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

// CPtiCoreLanguage::CPtiCoreLanguage

// 

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

// 

CPtiCoreLanguage::CPtiCoreLanguage()

	{

	}

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

// CPtiCoreLanguage::~CPtiCoreLanguage

// 

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

// 

EXPORT_C CPtiCoreLanguage::~CPtiCoreLanguage()

	{

	Clear();

	delete iHolder;

	iHolder = NULL;		

	}

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

// CPtiCoreLanguage::ConstructL

// 

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

// 

void CPtiCoreLanguage::ConstructL()

	{

	iHolder = new (ELeave) TPtiKeyMappingsHolder();

	}

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

// CPtiCoreLanguage::Clear

// 

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

// 

void CPtiCoreLanguage::Clear()

    {	

	if (iHolder)

	    {

        iHolder->Clear();		

	    }

	delete iKeyMapData;

	iKeyMapData = NULL;	

	iCores.Close();

	}

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

// CPtiCoreLanguage::SetLanguageCode

// 

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

// 

EXPORT_C void CPtiCoreLanguage::SetLanguageCode(TInt aCode)

	{

	if (aCode == iLanguageCode)

		{

		return;	

		}

	Clear();

	iLanguageCode = aCode;

	}

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

// CPtiCoreLanguage::SetLocalizedName

// 

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

// 

EXPORT_C void CPtiCoreLanguage::SetLocalizedName(const TDesC& aName)

	{	

	iLocalizedName.Copy(aName.Left(iLocalizedName.MaxLength()));	

	}

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

// CPtiCoreLanguage::GetKeymappings

// 

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

// 

EXPORT_C MPtiKeyMappings* CPtiCoreLanguage::GetKeymappings() const

	{

	__ASSERT_DEBUG(iHolder, User::Panic(KPtiEngineLangPanic, KErrCorrupt));	

	if (!iKeyMapData)	

		{

	    if (!iDataFactory)

		    {

		    CPtiDefaultCore* defaultCore = static_cast<CPtiDefaultCore*> (GetCoreForNumericMode());

		    if (defaultCore)

		        {

		        TRAPD(err, defaultCore->LoadFactoryForLanguageL(LanguageCode()));

		        if(err != KErrNone)

		        	{

		        	return NULL;

		        	}

		        }

            else

                {

                return NULL;

                }		        

		    }  		

		TRAP_IGNORE(LoadKeymappingsL());	

		}

	return iHolder->iKeyMappings;

	}

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

// CPtiCoreLanguage::GetQwertyKeymappings

// 

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

// 

EXPORT_C MPtiKeyMappings* CPtiCoreLanguage::GetQwertyKeymappings() const

	{

	__ASSERT_DEBUG(iHolder, User::Panic(KPtiEngineLangPanic, KErrCorrupt));	

	if (!iKeyMapData)	

		{

		if (!iDataFactory)

		    {

		    CPtiDefaultCore* defaultCore = static_cast<CPtiDefaultCore*> (GetCoreForNumericMode());

		    if (defaultCore)

		        {

		        TRAPD(err, defaultCore->LoadFactoryForLanguageL(LanguageCode()));

		        if(err != KErrNone)

		        	{

		        	return NULL;

		        	}

		        }

            else

                {

                return NULL;

                }		        

		    }  

		TRAP_IGNORE(LoadKeymappingsL());	

		}

	return iHolder->iQwertyKeyMappings;		

	}

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

// CPtiCoreLanguage::ClearMultitapping

// 

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

// 

EXPORT_C void CPtiCoreLanguage::ClearMultitapping()

	{

	__ASSERT_DEBUG(iHolder, User::Panic(KPtiEngineLangPanic, KErrCorrupt));	

	delete iHolder->iKeyMappings;

	iHolder->iKeyMappings = NULL;

	}

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

// CPtiCoreLanguage::ClearQwerty

// 

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

// 

EXPORT_C void CPtiCoreLanguage::ClearQwerty()

	{

	__ASSERT_DEBUG(iHolder, User::Panic(KPtiEngineLangPanic, KErrCorrupt));		

	delete iHolder->iQwertyKeyMappings;

	iHolder->iQwertyKeyMappings = NULL;

	}

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

// CPtiCoreLanguage::LocalizedNameDes

// 

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

// 

EXPORT_C TDes& CPtiCoreLanguage::LocalizedNameDes()

	{

	return iLocalizedName;

	}

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

// CPtiCoreLanguage::GetCore

// 

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

// 

EXPORT_C MPtiCore* CPtiCoreLanguage::GetCore(TPtiEngineInputMode aMode)

	{

	if (aMode == EPtiEngineNumeric)

		{

		return GetCoreForNumericMode();	

		}

	if (!iKeyMapData)	

		{

		TRAP_IGNORE(LoadKeymappingsL());	

		}		

	for (TInt i = 0; i < iCores.Count(); i++)

		{

		if (iCores[i].iInputMode == aMode)

			{

			return iCores[i].iCore;

			}

		}

	return NULL;

	}

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

// CPtiCoreLanguage::SetCore

// 

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

// 

EXPORT_C void CPtiCoreLanguage::SetCore(MPtiCore *aCore, TPtiEngineInputMode aMode)

	{

	SetCoreLocal(aCore, aMode);

	}

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

// CPtiCoreLanguage::SetKeyMappings

// 

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

// 

EXPORT_C void CPtiCoreLanguage::SetKeyMappings(MPtiKeyMappings* aMappings)

	{

	__ASSERT_DEBUG(iHolder, User::Panic(KPtiEngineLangPanic, KErrCorrupt));		

	delete iHolder->iKeyMappings;

	iHolder->iKeyMappings = aMappings;

	}

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

// CPtiCoreLanguage::SetQwertyKeyMappings

// 

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

// 

EXPORT_C void CPtiCoreLanguage::SetQwertyKeyMappings(MPtiKeyMappings* aMappings)

	{

	__ASSERT_DEBUG(iHolder, User::Panic(KPtiEngineLangPanic, KErrCorrupt));		

	delete iHolder->iQwertyKeyMappings;

	iHolder->iQwertyKeyMappings = aMappings;

	}

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

// CPtiCoreLanguage::HasInputMode

// 

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

// 

EXPORT_C TBool CPtiCoreLanguage::HasInputMode(TPtiEngineInputMode aMode) const

	{

	if (!iKeyMapData)	

		{

		TRAP_IGNORE(LoadKeymappingsL());	

		}	

	for (TInt i = 0; i < iCores.Count(); i++)

		{

		if (iCores[i].iInputMode == aMode)

			{	

			return ETrue;

			}

		}

	return EFalse;

	}

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

// CPtiCoreLanguage::HasCore

// 

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

// 

EXPORT_C TBool CPtiCoreLanguage::HasCore(MPtiCore* aCore) const

	{

	if (!iKeyMapData)	

		{

		TRAP_IGNORE(LoadKeymappingsL());	

		}	

	for (TInt i = 0; i < iCores.Count(); i++)

		{

		if (iCores[i].iCore == aCore)

			{

			return ETrue;

			}

		}

	return EFalse;

	}

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

// CPtiCoreLanguage::GetAvailableInputModesL

// 

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

// 

EXPORT_C void CPtiCoreLanguage::GetAvailableInputModesL(CArrayFix<TInt>* aResult)

	{

	if (!iKeyMapData)	

		{

		TRAP_IGNORE(LoadKeymappingsL());	

		}	

	if (aResult)

		{

		for (TInt i = 0; i < iCores.Count(); i++)

			{

			aResult->AppendL(iCores[i].iInputMode);

			}

		}

	}

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

// CPtiCoreLanguage::GetAvailableInputModesL

// 

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

// 

EXPORT_C void CPtiCoreLanguage::GetAvailableInputModesL(RArray<TInt>& aResult)

	{

	CleanupClosePushL( aResult );

	if (!iKeyMapData)	

		{

		TRAP_IGNORE(LoadKeymappingsL());	

		}	

	for (TInt i = 0; i < iCores.Count(); i++)

		{

		aResult.AppendL(iCores[i].iInputMode);

		}	

    CleanupStack::Pop();

	}

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

// CPtiCoreLanguage::RemoveCore

// 

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

// 	

EXPORT_C void CPtiCoreLanguage::RemoveCore(MPtiCore* aCore)

	{

	for (TInt i = 0; i < iCores.Count(); i++)	

		{

		if (iCores[i].iCore == aCore)	

			{

			iCores.Remove(i);

			i--;			

			}		

		}	

	}

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

// CPtiCoreLanguage::GetCoreForNumericMode

// 

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

// 	

CPtiCore* CPtiCoreLanguage::GetCoreForNumericMode() const

	{

	for (TInt i = 0; i < iCores.Count(); i++)	

		{

		if (iCores[i].iInputMode == EPtiEngineNumeric)	

			{

			return static_cast<CPtiCore*>(iCores[i].iCore);						

			}		

		}		

	return NULL;

	}

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

// CPtiCoreLanguage::LoadKeymappingsL

// 

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

// 	

void CPtiCoreLanguage::LoadKeymappingsL() const

	{	

	__ASSERT_DEBUG(iHolder, User::Panic(KPtiEngineLangPanic, KErrCorrupt));		

    iHolder->Clear();

	delete iKeyMapData;

	iKeyMapData = NULL; 

	if (iDataFactory)

	    {	    		

	    CPtiCore* defaultCore = GetCoreForNumericMode();	

	    iKeyMapData = static_cast<CPtiKeyMapData*>(iDataFactory->KeyMapDataForLanguageL(iLanguageCode));

	    if (iKeyMapData)

		    {

		    if (iKeyMapData->HasKeyData(EPtiKeyboard12Key))	

			    {				

			    iHolder->iKeyMappings = CPtiKeyMappings::NewL(iKeyMapData);

			    SetCoreLocal(defaultCore, EPtiEngineMultitapping);					

			    }

		    if (iKeyMapData->HasKeyData(EPtiKeyboardQwerty4x12) ||

		        iKeyMapData->HasKeyData(EPtiKeyboardQwerty4x10) ||

		        iKeyMapData->HasKeyData(EPtiKeyboardQwerty3x11))							

			    {					

			    SetCoreLocal(defaultCore, EPtiEngineQwerty);													

			    iHolder->iQwertyKeyMappings = CPtiQwertyKeyMappings::NewL(iKeyMapData);					

			    }

		    if (iKeyMapData->HasKeyData(EPtiKeyboardHalfQwerty))							

			    {					

			    SetCoreLocal(defaultCore, EPtiEngineHalfQwerty);																

		        iHolder->iHalfQwertyMappings = CPtiHalfQwertyKeyMappings::NewL(iKeyMapData);									    				  

			    }																			

		    }		

	    }

	}

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

// CPtiCoreLanguage::SetCoreLocal

// 

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

// 	

void CPtiCoreLanguage::SetCoreLocal(MPtiCore *aCore, TPtiEngineInputMode aMode) const

	{

	if (aMode > EPtiEngineInputModeNone && aMode <= EPtiEngineMaxInputModes)