/*
* Copyright (c) 2009 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:          
*
*/











#include    <PtiEngine.h>
#include <AknAppUi.h> //For CAknAppUi
#include <akntitle.h> //CAknTitlePane
#include    <aknfep.rsg>  //For R_SECONDARY_WRITING_LANG_NONE
#include <StringLoader.h>
#include <AknFepInternalCRKeys.h>
#include    <aknnotedialog.h>
#include    <avkon.rsg>
#include    <featmgr.h>
#include <e32property.h>
#include    <AvkonInternalCRKeys.h>
#include <aknenv.h>  
#include <AknSettingCache.h>
#include "AknFepUIAvkonCtrlDualLanguageSettingModel.h"

const TInt KAkFepDualLanguageMask = 0x03FF;
const TInt KAkFepDualLanguageBufSize128 = 128;

CAknFepDualLanguageSettingModel* CAknFepDualLanguageSettingModel::NewL()
    {
    CAknFepDualLanguageSettingModel* self = new( ELeave ) CAknFepDualLanguageSettingModel();
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

void CAknFepDualLanguageSettingModel::ConstructL()
    {
    iAknFepRepository = CRepository::NewL( KCRUidAknFep );
    }

CAknFepDualLanguageSettingModel::~CAknFepDualLanguageSettingModel()
    {
    if(iAknFepRepository)
        delete iAknFepRepository;
    }
void CAknFepDualLanguageSettingModel::GetSecondaryInputLanguagesL(
              CArrayFix<TInt>* aSeedLanguages,
              CDesCArray* aLanguageNames,
              CCoeEnv* aCoeEnv)
    {
    CPtiEngine* ptiEngine = CPtiEngine::NewL();
    CleanupStack::PushL( ptiEngine );

    CArrayFix<TInt>* languageCodeArray = aSeedLanguages;
    ptiEngine->GetAvailableLanguagesL( languageCodeArray );
    languageCodeArray->InsertL(0,0); // No secondary input language as the first item
    
    TInt count = languageCodeArray->Count();
    for ( TInt index = 0; index < count; ++index )
        {
        const TInt langCode = languageCodeArray->At(index);
        if(langCode == ELangTaiwanChinese ||
           langCode == ELangHongKongChinese ||
           langCode == ELangPrcChinese ||
           langCode == ELangJapanese ||
           langCode == ELangKorean )
            {
            languageCodeArray->Delete(index);
            count--;
            index--;
            }
        }

    HBufC* noneString = StringLoader::LoadLC( R_SECONDARY_WRITING_LANG_NONE, aCoeEnv);
    TPtr nonePtr( noneString->Des() );
    aLanguageNames->AppendL(nonePtr);
    CleanupStack::PopAndDestroy( noneString );
    
    HBufC* buffer = HBufC::NewLC( KAkFepDualLanguageBufSize128 );
    for ( TInt index = 1; index < count; ++index )
        {
        const TInt langId = languageCodeArray->At( index );

        TPtr ptrToBuffer( buffer->Des() );
        ptiEngine->GetLocalizedLanguageName( langId & KAkFepDualLanguageMask,
                                             ptrToBuffer );

        aLanguageNames->AppendL( ptrToBuffer );

        ptrToBuffer.Zero();
        }

    CleanupStack::PopAndDestroy( buffer );
    CleanupStack::PopAndDestroy( ptiEngine );
    }
void CAknFepDualLanguageSettingModel::ShowDualInputLanguageSettingListL(CCoeEnv* aCoeEnv)
    {
    CAknAppUi* appUi = static_cast<CAknAppUi*>(aCoeEnv->AppUi());

    CAknTitlePane* titlePane = static_cast<CAknTitlePane*>( appUi->StatusPane()->ControlL( TUid::Uid( EEikStatusPaneUidTitle ) ) );

    const TDesC* appTitle = titlePane->Text();
    HBufC* oldTitle = appTitle->AllocL();
    CleanupStack::PushL(oldTitle);
    HBufC* title = StringLoader::LoadLC( R_INPUT_LANGUAGE_SETTINGS_TITLE, aCoeEnv);
    titlePane->SetTextL( *title );
    CleanupStack::PopAndDestroy(title);
    
    //Launch dialog

    titlePane->SetTextL( *oldTitle );
    CleanupStack::PopAndDestroy(oldTitle);
    }


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

// ----------------------------------------------------------------------------
// CAknFepDualLanguageSettingModel::GetLanguagesFromPtiL
//
// Utility routine to get available languages with Symbian OS codes
// ----------------------------------------------------------------------------
//
void CAknFepDualLanguageSettingModel::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( KAkFepDualLanguageBufSize128 );
    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 & KAkFepDualLanguageMask,
                                             ptrToBuffer );

        if ( aInstalledLangCodes )
            {
            aSeedLanguages->AppendL( langId );
            }
        aLanguageNames->AppendL( ptrToBuffer );

        ptrToBuffer.Zero();
        }

    CleanupStack::PopAndDestroy( buffer );
    CleanupStack::PopAndDestroy( ptiEngine );
    }

TInt CAknFepDualLanguageSettingModel::LanguageL( TLanguageType aType )
    {
    TInt Language = KErrNone;
    switch ( aType )
        {
        case EAknFepDualLanguageSettingInputLanguage:
            {
            User::LeaveIfError(
                iAknFepRepository->Get( KAknFepInputTxtLang, Language ) );
            }
            break;
        case EAknFepDualLanguageSettingInputLanguageSecondary:
            {
            User::LeaveIfError(
                iAknFepRepository->Get( KAknFepInputTxtLangSecondary, Language ) );
            }
            break;
        default:
            break;
        }
    return Language;

    }


TBool CAknFepDualLanguageSettingModel::SetLanguageL( TLanguageType aType, TInt aLanguage )
    {
    TBool ret = ETrue;

    switch( aType )
        {
        case EAknFepDualLanguageSettingInputLanguage:
            {
            if( iAknFepRepository->Set( KAknFepInputTxtLang,
                                        aLanguage ) != KErrNone )
                {
                ret = EFalse;
                }
            
            if(ret)
                {
                // now inform all open apps of the switch
                TWsEvent event;
                event.SetType(KEikInputLanguageChange);
                CEikonEnv::Static()->WsSession().SendEventToAllWindowGroups(event);
                CAknEnv::Static()->SettingCache().Update(KEikInputLanguageChange);
                }
            
            // See if it cannot do predictive text entry
            if( !CheckDictionaryFromPtiL( aLanguage ) )
                {
                CAknNoteDialog* dlg = new (ELeave) CAknNoteDialog( );
                dlg->ExecuteDlgLD(
                    CAknNoteDialog::EShortTimeout,
                    CAknNoteDialog::ENoTone,
                    R_AVKON_T9_NOTE_NO_AVAILABLE );                                   
              
                }
            }
            break;
        case EAknFepDualLanguageSettingInputLanguageSecondary:
            {
            if( iAknFepRepository->Set( KAknFepInputTxtLangSecondary,
                                        aLanguage ) != KErrNone )
                {
                ret = EFalse;
                }
            if(ret)
                {
                // now inform all open apps of the switch
                // same event as primary input 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;
        default:
            break;

        }
    return ret;
    }

// ----------------------------------------------------------------------------
// CGSLangModel::CheckDictionaryFromPtiL
//
// Checks if the selected language supports predictive text input.
// In case this returns EFalse, the UI display's "Not available"
// for Predictive text input.
// ----------------------------------------------------------------------------
//
TBool CAknFepDualLanguageSettingModel::CheckDictionaryFromPtiL( TInt aLangCode )
    {
    TBool langSupport = EFalse;

    if ( FeatureManager::FeatureSupported( KFeatureIdChinese ) ||
        FeatureManager::FeatureSupported( KFeatureIdJapanese ) )
        {
        langSupport = ETrue;
        }
    else
        {
        CPtiEngine* ptiEngine = CPtiEngine::NewL();
        CleanupStack::PushL( ptiEngine );

        MPtiLanguage* ptiLang = ptiEngine->GetLanguage( aLangCode );
        if ( ptiLang )
            {
            // the check here should be based on the keyboard      
            TInt keyboardLayout = 0;
            RProperty::Get(KCRUidAvkon, KAknKeyBoardLayout, keyboardLayout);
            TPtiKeyboardType layout = (TPtiKeyboardType)keyboardLayout;
            switch(layout)
                {
                case EPtiKeyboardHalfQwerty:
                    langSupport = ptiLang->HasInputMode( (TPtiEngineInputMode)EPtiEngineHalfQwertyPredictive);
                    break;
                case EPtiKeyboardQwerty4x12:
                case EPtiKeyboardQwerty4x10:  
                case EPtiKeyboardQwerty3x11:
                case EPtiKeyboardCustomQwerty:
                    langSupport = ptiLang->HasInputMode( (TPtiEngineInputMode)EPtiEngineQwertyPredictive);
                    break;
                case EPtiKeyboardNone:
                case EPtiKeyboard12Key:
                    langSupport = ptiLang->HasInputMode( (TPtiEngineInputMode)EPtiEnginePredictive);
                    break;
                default:
                    langSupport = ptiLang->HasInputMode( (TPtiEngineInputMode)EPtiEnginePredictive);
                    break;    
                }

            }
        CleanupStack::PopAndDestroy( ptiEngine );
        ptiLang = NULL;
        }

    return langSupport;
    }