/*

* 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:   Default core for predective text input engine.

*               Implements basic qwerty & multitapping input.  

*

*/

#include <e32property.h>

#include "PtiDefaultCore.h"

#include "PtiLanguage.h"

#include "PtiEngine.h"

#include "PtiKeyMappings.h"

#include <ptiengine.rsg>

#include "PtiDefaultNumberModeMappingdata.h"

#include <data_caging_path_literals.hrh> 

// CONSTANTS

const TInt KMultiTapTimeoutMS = 1000000;

//const TInt KPtiKeymappingsDefaultImplementation = 0x10281897;

_LIT(KDefaultCoreVendor, "Default core");

#ifdef _DEBUG

_LIT(KPtiEnginePanic, "CPtiDefaultCore");

#endif

// lam with alef ligatures are entered as one press but are actually two symbols

// These four arabic characters are handled as a special case.

const TUint16 KArarbicLigatureLamWithAlefWithMaddaAboveIsolatedForm = 0xFEF5;

const TUint16 KArarbicLigatureLamWithAlefWithHamzaAboveIsolatedForm = 0xFEF7;

const TUint16 KArarbicLigatureLamWithAlefWithHamzaBelowIsolatedForm = 0xFEF9;

const TUint16 KArarbicLigatureLamWithAlefIsolatedForm               = 0xFEFB;

_LIT(KArarbicLigatureLamWithAlefWithMaddaAboveIsolatedSequence, "\x0644\x622");

_LIT(KArarbicLigatureLamWithAlefWithHamzaAboveIsolatedSequence, "\x0644\x623");

_LIT(KArarbicLigatureLamWithAlefWithHamzaBelowIsolatedSequence, "\x0644\x625");

_LIT(KArarbicLigatureLamWithAlefIsolatedSequence, "\x0644\x627");

//

// CMultiTapTimer

//

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

// CMultiTapTimer::NewL

// 

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

// 

CMultiTapTimer* CMultiTapTimer::NewL(TCallBack aCallback)

	{

	CMultiTapTimer* self = new(ELeave)CMultiTapTimer(aCallback);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();	// self

	return self;

	}

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

// CMultiTapTimer::CMultitapTimer

// 

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

// 

CMultiTapTimer::CMultiTapTimer(TCallBack aCallback)

:CTimer(EPriorityStandard), iCallback(aCallback)

	{

	}

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

// CMultiTapTimer::ConstructL

// 

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

// 

void CMultiTapTimer::ConstructL()

	{

	CTimer::ConstructL();

	CActiveScheduler::Add(this);

	}

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

// CMultiTapTimer::After

// 

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

// 

void CMultiTapTimer::After(TTimeIntervalMicroSeconds32 aInterval)

	{

	if (IsActive())

		{

		Cancel();

		}

	CTimer::After(aInterval);

	}

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

// CMultiTapTimer::RunL

// 

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

// 

void CMultiTapTimer::RunL()

	{

	iCallback.CallBack();

	}

//

// CPtiDefaultCore

//

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

// CPtiDefaultCore::NewL

// 

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

// 

CPtiDefaultCore* CPtiDefaultCore::NewL(CPtiEngine* aOwner, TDes* aTextBuffer)

	{

	CPtiDefaultCore *core = new (ELeave) CPtiDefaultCore(aOwner, aTextBuffer);

	CleanupStack::PushL( core );

	core->ConstructL();

	CleanupStack::Pop(); // core

	return core;

	}

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

// CPtiDefaultCore::CPtiDefaultCore

// .

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

// 

CPtiDefaultCore::CPtiDefaultCore()

	{

	}

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

// CPtiDefaultCore::CPtiDefaultCore

// 

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

// 

CPtiDefaultCore::CPtiDefaultCore(CPtiEngine* aOwner, TDes* aTextBuffer) : iOwner(aOwner), iTextBuffer(aTextBuffer)

	{

	}

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

// CPtiDefaultCore::~CPtiDefaultCore

// 

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

// 

CPtiDefaultCore::~CPtiDefaultCore()

	{

	if (iTimer)

		{

		iTimer->Cancel();

		}

    ShutDownKeymapFactory();

	delete iTimer;	

	delete iNumericMappings;

	delete iNumericData;

    iFactoryBindings.Close();    	

	}

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

// CPtiDefaultCore::ConstructL

// 

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

// 

void CPtiDefaultCore::ConstructL()

	{

	FillCoreInfo();

	TCallBack timerExpire(TimerExpire, this);

	iTimer = CMultiTapTimer::NewL(timerExpire);

	iNumericData = CPtiNumberModeDataImpl::NewL();

	iNumericMappings = CPtiKeyMappings::NewL(iNumericData);  

	}

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

// CPtiDefaultCore::InitializeL

// 

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

// 

void CPtiDefaultCore::InitializeL(CPtiEngine* aOwner, TDes* aTextBuffer, CArrayPtrFlat<CPtiCoreLanguage>* aLanguageList, TBool /*aUseDefautUserDictionary*/)

	{

	iOwner = aOwner;

	iTextBuffer = aTextBuffer;

    iLanguageList = aLanguageList;	

    TInt count = 0;

    TInt err = RProperty::Get(KPtiEnginePSUid, EKeyMapPropertyCount, count);

    if (err == KErrNone && count > 0)

        {

        // PS key found, keymap implementation list has been created and can be read

        TBuf16<256> dataBuffer;

        err = RProperty::Get(KPtiEnginePSUid, EKeyMapPropertyData, dataBuffer);

        if( err == KErrNone )

            {

            TInt langId;

            TInt factoryUid;

            for(TInt i = 0; i < count; i++ )

                {

                langId = dataBuffer[3*i];

                factoryUid = (dataBuffer[3*i+1] << 16) + dataBuffer[3*i+2];

                CPtiCoreLanguage* language = CPtiCoreLanguage::NewL();

                language->SetLanguageCode(langId);

		        language->SetCore(this, EPtiEngineNumeric);	

	            CleanupStack::PushL( language );     

	       	    aLanguageList->AppendL( language );

	            CleanupStack::Pop(); // language

                TPtiDataFactoryBinding newBind(langId, factoryUid);

                iFactoryBindings.AppendL(newBind);

                }

            return;

            }

        }

    // PS key not defined or error, we need to fetch the data from dll:s

	RArray<TInt> dataImpl;

	CleanupClosePushL(dataImpl);

	CPtiKeyMapDataFactory::ListImplementationsL(dataImpl);

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

	    {

        ShutDownKeymapFactory();

	    iKeyMapDataFactory = CPtiKeyMapDataFactory::CreateImplementationL(TUid::Uid(dataImpl[i]));	  	    	  	   

	    ListDataFactoryLanguagesL(iKeyMapDataFactory, dataImpl[i], aLanguageList);	     

	    }

	if (!iFactoryBindings.Count())

	    {

	    // Cannot function without keymapping data.

	    User::Leave(KErrCorrupt);

	    } 

    // Write language->dll mapping data to P/S-key so we don't need to load every dll later

    TBuf16<256> dataBuffer;

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

       {

       dataBuffer.Append(iFactoryBindings[i].iLanguage); // Language id should fit in 16 bits

       dataBuffer.Append(iFactoryBindings[i].iFactoryImplUid >> 16); // 32-bit Uid is appended in two parts

       dataBuffer.Append(iFactoryBindings[i].iFactoryImplUid);

       }

    // If these fail, then they just fail.                  

    RProperty::Set(KPtiEnginePSUid, EKeyMapPropertyCount, iFactoryBindings.Count());  

    RProperty::Set(KPtiEnginePSUid, EKeyMapPropertyData, dataBuffer);        

	CleanupStack::PopAndDestroy(); // dataImpl    

	}

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

// CPtiDefaultCore::OpenLanguageL

// 

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

// 

TInt CPtiDefaultCore::OpenLanguageL(CPtiCoreLanguage* aLanguage)

	{		

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

	ClearFlag(EPtiFlagVowelSeq);	

	return err;

	}

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

// CPtiDefaultCore::CloseLanguageL

// 

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

// 

TInt CPtiDefaultCore::CloseLanguageL()

	{

	if (iOwner->CurrentLanguage())

	    {

	    CPtiCoreLanguage* curLang = static_cast<CPtiCoreLanguage*>(iOwner->CurrentLanguage());

	    curLang->SetKeyMapDataFactory(NULL);  

	    }			

	ClearFlag(EPtiFlagVowelSeq);	

	return KErrNone;

	}

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

// CPtiDefaultCore::GetCurrentWord

// 

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

// 

TPtrC CPtiDefaultCore::GetCurrentWord() const

	{

	__ASSERT_DEBUG(iTextBuffer, User::Panic(KPtiEnginePanic, KErrCorrupt));

	return TPtrC(iTextBuffer->Ptr());

	}

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

// CPtiDefaultCore::CommitCurrentWord

// 

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

// 

TInt CPtiDefaultCore::CommitCurrentWord()

	{

	ClearBuffer();

	return KErrNone;

	}

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

// CPtiDefaultCore::NumberOfCandidates

// 

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

// 

TInt CPtiDefaultCore::NumberOfCandidates()

	{

	__ASSERT_DEBUG(iTextBuffer, User::Panic(KPtiEnginePanic, KErrCorrupt));

	if (iTextBuffer->Length() == 0)

		{

		return 0;	

		}

	return 1;

	}

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

// CPtiDefaultCore::FillCoreInfo

// 

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

// 

void CPtiDefaultCore::FillCoreInfo()

	{

	iCoreInfo.SetCapsBits(0);

	iCoreInfo.SetMaxWordLength(KDefaulCoreMaximumWordLength);

	iCoreInfo.SetVendorString( KDefaultCoreVendor );

	iCoreInfo.SetMaxNumberOfCandidates(1);

	iCoreInfo.SetUid(KDefaultCoreUid);

	}

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

// CPtiDefaultCore::SetReordering

// 

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

// 

TInt CPtiDefaultCore::SetReordering(TBool aStatus)

	{

	if (aStatus)

		{

		return KErrNotSupported;

		}

	return KErrNone;

	}

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

// CPtiDefaultCore::AppendKeyPress

// 

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

// 

void CPtiDefaultCore::AppendKeyPress(TPtiKey aKey)

	{

	__ASSERT_DEBUG(iOwner, User::Panic(KPtiEnginePanic, KErrCorrupt));

	CPtiCoreLanguage* lang = static_cast<CPtiCoreLanguage*>(iOwner->CurrentLanguage());

	const TPtiEngineInputMode inputMode = iOwner->InputMode();

	const TBool qwerty = iOwner->IsQwertyBasedMode(inputMode);

	TBool append = ETrue;

	TUint16 overridingDeadKey = 0;

	ClearFlag(EPtiGetAllFlag);		

	__ASSERT_DEBUG(lang, User::Panic(KPtiEnginePanic, KErrCorrupt));

	MPtiKeyMappings* maps = NULL;

	if (inputMode == EPtiEngineNumeric)

		{

		maps = iNumericMappings;

		}

    else if (inputMode == EPtiEngineHalfQwerty)		

        {

        if (lang->HasInputMode(EPtiEngineHalfQwerty))

            {

	        maps = lang->GetHalfQwertyKeymappings();            

            }        

        }		

	else if (qwerty)

		{

		if (lang->HasInputMode(EPtiEngineQwerty))

			{

			maps = lang->GetQwertyKeymappings();

			}

		}

	else

		{

		if (lang->HasInputMode(EPtiEngineMultitapping))

			{

			maps = lang->GetKeymappings();

			}

		}

	if (!maps)

		{

		iTimer->Cancel();

		return;

		}

	if (iTimer->IsActive())

		{

		TUint16 chr = maps->NextKey(aKey, append, iOwner->Case());

		if (chr && (!append) && (iTextBuffer->Length() > 0))

			{

			iTextBuffer->SetLength(iTextBuffer->Length() - 1);	

			}

		if (iTextBuffer->Length() < iTextBuffer->MaxLength())

			{

			if (chr)

				{

				iTextBuffer->Append(chr);

				}

			}

		}

	else

		{

		if (iTextBuffer->Length() < iTextBuffer->MaxLength())

			{

			if (qwerty)

				{

				CPtiQwertyKeyMappings* qmap = static_cast<CPtiQwertyKeyMappings*>(maps);		

				if (lang->LanguageCode() == ELangVietnamese)

					{

					qmap->SetFlag(CPtiQwertyKeyMappings::ETrackVietnameseToneMarksAndVowels);

					}

				else

					{

					qmap->ResetFlag(CPtiQwertyKeyMappings::ETrackVietnameseToneMarksAndVowels);

					}					

				if (qmap->DeadKey() && (aKey == qmap->CurrentKey()))

					{

					overridingDeadKey = qmap->DeadKeyRootChar();				

					} 

				}

			TUint16 chr = maps->StartMapping(aKey, iOwner->Case(), inputMode);

			if (chr == KPtiGetAllMarker) 

				{

				if (lang->LanguageCode() == ELangHindi)

					{									

					TPtrC ptr = maps->GetAll(iOwner->Case());				

					iTextBuffer->Append(ptr.Left(iTextBuffer->MaxLength() - iTextBuffer->Length()));

					SetFlag(EPtiGetAllFlag);		

					}

				}			

			else if (chr)

				{

                switch (chr)

                	{

          			case KArarbicLigatureLamWithAlefWithMaddaAboveIsolatedForm:

                 	     iTextBuffer->Append(KArarbicLigatureLamWithAlefWithMaddaAboveIsolatedSequence);

                 	     SetFlag(EPtiDoubleWideEntry);

                 	     break;

            		case KArarbicLigatureLamWithAlefWithHamzaAboveIsolatedForm:

                 	     iTextBuffer->Append(KArarbicLigatureLamWithAlefWithHamzaAboveIsolatedSequence);

                 	     SetFlag(EPtiDoubleWideEntry);                 

                 	     break;

            		case KArarbicLigatureLamWithAlefWithHamzaBelowIsolatedForm:

                 	     iTextBuffer->Append(KArarbicLigatureLamWithAlefWithHamzaBelowIsolatedSequence);

                         SetFlag(EPtiDoubleWideEntry);                 

                         break; 

                    case KArarbicLigatureLamWithAlefIsolatedForm:

                         iTextBuffer->Append(KArarbicLigatureLamWithAlefIsolatedSequence);      

                         SetFlag(EPtiDoubleWideEntry);                 

                         break;

                    default:       

                         iTextBuffer->Append(chr);    

                     }                

				}

			if (qwerty)

				{

				// There was dead key press waiting, but last key press didn't

				// contain dead key data, so both keys will be inserted.	

				CPtiQwertyKeyMappings* qmap = static_cast<CPtiQwertyKeyMappings*>(maps);

				if (overridingDeadKey != 0) 

					{				

					qmap->ClearDeadKey();

					}				

				else if (qmap->DeadKeyRootFlag())

					{

					if (iTextBuffer->Length() < iTextBuffer->MaxLength())

						{	

						SetFlag(EPtiDeadKeyRootFlag); // This will indicate PtiEngine that extra character 

						                             // was added to buffer.

                        chr = maps->StartMapping(aKey, iOwner->Case());

                        if ( chr )

                            {

                            iTextBuffer->Append( chr );

                            }

						}

					}

				else if ((qmap->VowelSequenceFlag()) &&