/*

* Copyright (c) 2005 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:  Data model for GSLangPlugin.

*

*/

// INCLUDE FILES

#include    "GSLangModel.h"

#include    "GSLangContainer.h"

#include    "GSLangPlugin.h"

#include    <GSLangPluginRsc.rsg>

#include    <AknFepInternalCRKeys.h>

#include    <aknnotedialog.h>

#include    <aknradiobuttonsettingpage.h>

#include    <aknViewAppUi.h>

#include    <avkon.rsg>

#include    <CommonEngineDomainCRKeys.h> //Ui language

#include    <e32math.h>

#include    <featmgr.h>

#include    <hal.h>

#include    <PtiEngine.h>

#include    <ScreensaverInternalCRKeys.h>  //double declaration of KScreenSaverPluginName

#include    <settingsinternalcrkeys.h>

#include    <startupdomaincrkeys.h>

#include    <ctsydomainpskeys.h>

#include    <languages.hrh>

#include <AknFepGlobalEnums.h> //For chinese input modes

// For Phonetic Input of Hindi

#include <PtiIndicDefs.h>

#include <sysutil.h>

#ifdef RD_INTELLIGENT_TEXT_INPUT

#include    <AvkonInternalCRKeys.h>

#include <StringLoader.h>

#include <coemain.h>

#endif

#include <aknenv.h>  

#include <AknSettingCache.h>

//CONSTANTS

const TInt KGSDiskSpaceLimitForLanguageChange = 300000;

// ================= MEMBER FUNCTIONS =======================

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

// CGSLangModel::NewL

//

// EPOC two-phased constructor

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

//

CGSLangModel* CGSLangModel::NewL( CGSLangContainer* aContainer )

    {

    CGSLangModel* self = new( ELeave ) CGSLangModel( aContainer );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CGSLangModel::CGSLangModel

//

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CGSLangModel::CGSLangModel( CGSLangContainer* aContainer )

    : iContainer( aContainer )

    {

    }

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

// CGSLangModel::ConstructL

//

// EPOC default constructor can leave.

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

//

void CGSLangModel::ConstructL()

    {

    InitializeCentralRepositoriesL();

    // start listening to CenRep key changes for ITL

    iNotifyHandlerForITL = CCenRepNotifyHandler::NewL( *this, 

                           *iAknFepRepository,

                           CCenRepNotifyHandler::EIntKey, 

                           KAknFepInputTxtLang );

    iNotifyHandlerForITL->StartListeningL();

    // start listening to CenRep key changes for T9 on/off

    iNotifyHandlerForT9 = CCenRepNotifyHandler::NewL( *this, 

                           *iAknFepRepository,

                           CCenRepNotifyHandler::EIntKey, 

                           KAknFepPredTxtFlag );

    iNotifyHandlerForT9->StartListeningL();

    if ( FeatureManager::FeatureSupported( KFeatureIdJapanese ) )

        {

        // start listening to CenRep key changes for Japanese predictive mode

        iNotifyHandlerForJapanesePredTxt = CCenRepNotifyHandler::NewL( *this, 

                               *iAknFepRepository,

                               CCenRepNotifyHandler::EIntKey, 

                               KAknFepJapanesePredTxtFlag );

        iNotifyHandlerForJapanesePredTxt->StartListeningL();

        }

#ifdef RD_INTELLIGENT_TEXT_INPUT

    // start listening to CenRep key changes for T9 on/off

    iNotifyHandlerForPredExt = CCenRepNotifyHandler::NewL( *this, 

                           *iAknFepRepository,

                           CCenRepNotifyHandler::EIntKey, 

                           KAknFepPredTxtFlagExtension );

    iNotifyHandlerForPredExt->StartListeningL();

#endif

    }

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

// CGSLangModel::~CGSLangModel

//

// Destructor

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

//

CGSLangModel::~CGSLangModel()

    {

    if ( iNotifyHandlerForITL )

        {

        iNotifyHandlerForITL->StopListening();

        }

    delete iNotifyHandlerForITL;

    if ( iNotifyHandlerForT9 )

        {

        iNotifyHandlerForT9->StopListening();

        }

    delete iNotifyHandlerForT9;

    if ( iNotifyHandlerForJapanesePredTxt )

        {

        iNotifyHandlerForJapanesePredTxt->StopListening();

        }

    delete iNotifyHandlerForJapanesePredTxt;

#ifdef RD_INTELLIGENT_TEXT_INPUT

    if ( iNotifyHandlerForPredExt )

        {

        iNotifyHandlerForPredExt->StopListening();

        }

    delete iNotifyHandlerForPredExt;

#endif

    CloseCentralRepositories();

    }

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

// CGSLangModel::InitializeCentralRepositoriesL

//

// Creating and setting keys for the Central Repository

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

//

void CGSLangModel::InitializeCentralRepositoriesL()

    {

    iPersonalizationRepository =

        CRepository::NewL( KCRUidPersonalizationSettings );

    iLocaleRepository = CRepository::NewL( KCRUidLocaleSettings );

    iStartupConfRepository = CRepository::NewL( KCRUidStartupConf );

    iAknFepRepository = CRepository::NewL( KCRUidAknFep );

    iCommonEngineRepository = CRepository::NewL( KCRUidCommonEngineKeys );

    iScreensaverRepository = CRepository::NewL( KCRUidScreenSaver );

    }

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

// CGSLangModel::CloseCentralRepositoriesL

//

// Creating and setting keys for the Central Repository

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

//

void CGSLangModel::CloseCentralRepositories()

    {

    if ( iPersonalizationRepository )

        {

        delete iPersonalizationRepository;

        iPersonalizationRepository = NULL;

        }

    if ( iLocaleRepository )

        {

        delete iLocaleRepository;

        iLocaleRepository = NULL;

        }

    if ( iStartupConfRepository )

        {

        delete iStartupConfRepository;

        iStartupConfRepository = NULL;

        }

    if ( iAknFepRepository )

        {

        delete iAknFepRepository;

        iAknFepRepository = NULL;

        }

    if ( iCommonEngineRepository )

        {

        delete iCommonEngineRepository;

        iCommonEngineRepository = NULL;

        }

    if ( iScreensaverRepository )

        {

        delete iScreensaverRepository;

        iScreensaverRepository = NULL;

        }

    }

// ================= DATA ACCESS FUNCTIONS ==================

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

// CGSLangModel::GetLanguagesFromPtiL

//

// Utility routine to get available languages with Symbian OS codes

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

//

void CGSLangModel::GetLanguagesFromPtiL(

    CArrayFix<TInt>* aInstalledLangCodes,

    CArrayFix<TInt>* aSeedLanguages,

    CDesCArray* aLanguageNames )

    {

    CPtiEngine* ptiEngine = CPtiEngine::NewL();

    CleanupStack::PushL( ptiEngine );

    CArrayFix<TInt>* languageCodeArray = aSeedLanguages;

    if ( aInstalledLangCodes )

        {

        languageCodeArray = aInstalledLangCodes;

        }

    else

        {

        ptiEngine->GetAvailableLanguagesL( languageCodeArray );

        }

    HBufC* buffer = HBufC::NewLC( KGSBufSize128 );

    const TInt count = languageCodeArray->Count();

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

        {

        const TInt langId = languageCodeArray->At( index );

        TPtr ptrToBuffer( buffer->Des() );

        ptiEngine->GetLocalizedLanguageName( langId & KGSLanguageMask,

                                             ptrToBuffer );

        if ( aInstalledLangCodes )

            {

            aSeedLanguages->AppendL( langId );

            }

        aLanguageNames->AppendL( ptrToBuffer );

        ptrToBuffer.Zero();

        }

    CleanupStack::PopAndDestroy( buffer );

    CleanupStack::PopAndDestroy( ptiEngine );

    }

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

// CGSLangModel::LanguageL

//

//

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

//

TInt CGSLangModel::LanguageL( TLanguage aType )

    {

    TInt Language = KErrNone;

    switch ( aType )

        {

        case EGSUiLanguage:

            {

            User::LeaveIfError(

                iCommonEngineRepository->Get( KGSDisplayTxtLang, Language ) );

            }

            break;

        case EGSInputLanguage:

            {

            User::LeaveIfError(

                iAknFepRepository->Get( KAknFepInputTxtLang, Language ) );

            }

            break;

#ifdef RD_INTELLIGENT_TEXT_INPUT

#ifdef FF_DUAL_LANGUAGE_SUPPORT

        case EGSInputLanguageSecondary:

            {

            User::LeaveIfError(

                iAknFepRepository->Get( KAknFepInputTxtLangSecondary, Language ) );

            }

            break;

#endif

#endif

        default:

            break;

        }

    return Language;

    }

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

// CGSLangModel::SetLanguageL

//

//

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

//

TBool CGSLangModel::SetLanguageL( TLanguage aType, TInt aLanguage )

    {

    TBool ret = ETrue;

    switch( aType )

        {

        case EGSUiLanguage:

            {

            // Never set Language code 0 to HAL

            if ( aLanguage !=0 )

                {

                if ( HAL::Set( HAL::ELanguageIndex, aLanguage ) != KErrNone )

                    {

                    ret = EFalse;

                    }

                }

            if ( iCommonEngineRepository->

                    Set( KGSDisplayTxtLang, aLanguage ) != KErrNone )

                {

                ret = EFalse;

                }

            TBool NbrModeSaved = EFalse;

            if ( aLanguage == ELangArabic || User::Language() == ELangArabic )

                {

                //numberMode = EGSNumberModeArabicIndic;

                SetDefaultNumberMode( EGSNbrModeArabic, 

                                      EGSNbrModeTypeArabic );

                NbrModeSaved = ETrue;

                }

            else if ( ( aLanguage == ELangUrdu || User::Language() == ELangUrdu ) || 

                      ( aLanguage == ELangFarsi || User::Language() == ELangFarsi ) )

                {

                //numberMode = EGSNumberModeEasternArabicIndic;

                SetDefaultNumberMode( EGSNbrModeLatin, 

                                      EGSNbrModeTypeEasternArabic );

                NbrModeSaved = ETrue;

                }

            else if ( aLanguage == ELangHindi || User::Language() == ELangHindi ||

                      aLanguage == ELangMarathi || User::Language() == ELangMarathi )

                {

                //numberMode = EGSNumberModeIndic;

                SetDefaultNumberMode( EGSNbrModeLatin, 

                                      EGSNbrModeTypeIndic );

                NbrModeSaved = ETrue;

                }

            //if number mode is not set above, then set it to Latin with respective

            //number mode types. This part might be executed when Automatic is

            //selected and the SIM card does not support the language.

            if ( !NbrModeSaved )

                {

                TInt nbrModeType = EGSNbrModeTypeIndic;

                if ( aLanguage == ELangArabic || User::Language() == ELangArabic )

                    {

                    nbrModeType = EGSNbrModeTypeArabic;

                    }

                else if ( ( aLanguage == ELangUrdu || User::Language() == ELangUrdu ) 

                     || ( aLanguage == ELangFarsi || User::Language() == ELangFarsi ) )

                    {

                    nbrModeType = EGSNbrModeTypeEasternArabic;

                    }

                //EGSNumberModeLatin is true in both cases;

                SetDefaultNumberMode( EGSNbrModeLatin,

                                      nbrModeType );

                }

            }

            break;

        case EGSInputLanguage:

            {

            if( iAknFepRepository->Set( KAknFepInputTxtLang,

                                        aLanguage ) != KErrNone )

                {

                ret = EFalse;

                }

			if(ret)

                {

                //inform all other apps about language change.

                TWsEvent event;

                event.SetType( KEikInputLanguageChange  );

                CEikonEnv::Static()->WsSession().SendEventToAllWindowGroups(event);

                CAknEnv::Static()->SettingCache().Update(KEikInputLanguageChange);

                }

            // See if it cannot do predictive text entry

    		TBool checkEngine = EFalse;

    		if (!( aLanguage == ELangPrcChinese ||

         	       aLanguage == ELangHongKongChinese || 

         	       aLanguage == ELangTaiwanChinese ) 

         	   )

    			{

	    		if ( FeatureManager::FeatureSupported( KFeatureIdChinese ) )

		    		{

        			aLanguage = ELangEnglish;

        			checkEngine = ETrue;   			

    				}

	   			if (!CheckDictionaryFromPtiL( aLanguage, checkEngine))

    	            {

        	        CAknNoteDialog* dlg = new (ELeave) CAknNoteDialog( );

            	    dlg->ExecuteDlgLD(

                	    CAknNoteDialog::EShortTimeout,

                    	CAknNoteDialog::ENoTone,

	                    R_AVKON_T9_NOTE_NO_AVAILABLE );

    	             //SetT9OnOffMode(0);

        	         SetPredictiveOnOff( EGSLangOther, 0 );

            	    }

    			}

            }

            break;

#ifdef RD_INTELLIGENT_TEXT_INPUT

#ifdef FF_DUAL_LANGUAGE_SUPPORT

        case EGSInputLanguageSecondary:

            {

            if( iAknFepRepository->Set( KAknFepInputTxtLangSecondary,

                                        aLanguage ) != KErrNone )

                {

                ret = EFalse;

                }

            if(ret)

                {

                //inform all other apps about language change.

                TWsEvent event;

                event.SetType( KEikInputLanguageChange  );

                CEikonEnv::Static()->WsSession().SendEventToAllWindowGroups(event);

                CAknEnv::Static()->SettingCache().Update(KEikInputLanguageChange);

                }

            // Secondary input language does not need prediction

            // so we don't check for it

            }

            break;

#endif            

#endif

        default:

            break;

        }

    return ret;

    }

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

// CGSLangModel::DefaultNumberMode

//

//

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

//

TInt CGSLangModel::DefaultNumberMode( TInt aNbrModeType )

    {

    TInt value = KGSSettingOff;

    switch ( aNbrModeType )

        {

        case EGSNbrModeTypeArabic:

        case EGSNbrModeTypeEasternArabic:

            iLocaleRepository->Get( KSettingsDefaultNumberMode, value );

            break;

        case EGSNbrModeTypeIndic:

            iLocaleRepository->Get( KSettingsIndicDefaultNumberMode, value );

            break;

        default:

            break;

        }

    return value;

    }

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

// CGSLangModel::SetDefaultNumberMode

//

// Set default number mode for non-latin languagues

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

//

void CGSLangModel::SetDefaultNumberMode( TInt aMode, TInt aNbrModeType )

    {

    if ( aNbrModeType == EGSNbrModeTypeArabic ||

         aNbrModeType == EGSNbrModeTypeEasternArabic )

        {

        iLocaleRepository->Set( KSettingsDefaultNumberMode, aMode );

        }

    else

        {

        iLocaleRepository->Set( KSettingsIndicDefaultNumberMode, aMode );

        }

    TLocale locale;

    if ( aMode == EGSNbrModeLatin )