/*

* 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:  Container for GSLangPlugin.

*

*/

// INCLUDE FILES

#include    "GSLangContainer.h"

#include    "GSLangPlugin.h"

#include    "GSLangPlugin.hrh"

#include    "GSLangModel.h"

#include    <gslistbox.h> // CGSListBoxItemTextArray

#include    <gscommon.hrh>

#include    <gslangpluginrsc.rsg>

#include    <bldvariant.hrh>

#include    <aknappui.h>

#include    <AknFepGlobalEnums.h>

#include    <AknFepInternalCRKeys.h>

#include    <aknlists.h>

#include    <akntitle.h> 

//#include    <ApProtHandler.h> // CApProtHandler

//#include    <aputils.h> // CApUtils

#include    <commdb.h> // CCommsDatabase

//#include    <csxhelp/cp.hlp.hrh>

#include    <gsfwviewuids.h>

#include    <eikspane.h>

#include    <featmgr.h>

#include    <syslangutil.h>

#include    <AknFepInternalCRKeys.h>

#include    <AvkonInternalCRKeys.h>

// CONSTANTS

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

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

// CGSLangContainer::CGSLangContainer

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

// might leave.

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

//

CGSLangContainer::CGSLangContainer()

    {

    }

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

// CGSLangContainer::ConstructL(const TRect& aRect)

// Symbian OS two phased constructor

//

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

//

void CGSLangContainer::ConstructL( const TRect& aRect )

    {

    iModel = CGSLangModel::NewL( this );

    iUpdateITL = EFalse;

    iListBox = new( ELeave ) CAknSettingStyleListBox;

    BaseConstructL( aRect, R_GS_LANG_PLUGIN_TITLE, R_LANG_LBX );

    }

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

// CGSLangContainer::ConstructListBoxL(TInt aResLbxId)

// Construct the listbox items

//

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

//

void CGSLangContainer::ConstructListBoxL( TInt aResLbxId )

    {

    iListBox->ConstructL( this, EAknListBoxSelectionList );

    iListboxItemArray = CGSListBoxItemTextArray::NewL( aResLbxId,

        *iListBox, *iCoeEnv );

    iListBox->Model()->SetItemTextArray( iListboxItemArray );

    iListBox->Model()->SetOwnershipType( ELbmDoesNotOwnItemArray );

    // Set up UI language arrays - Display Text Language Construction

    CArrayFixFlat<TInt>* systemEpocLanguageCodes = 0;

    // This creates the list itself

    TInt error = SysLangUtil::GetInstalledLanguages( systemEpocLanguageCodes );

    if ( error != KErrNone )

        {

        delete systemEpocLanguageCodes;

        User::Leave( error );

        }

    CleanupStack::PushL( systemEpocLanguageCodes );

    delete iDtLanguagesCodes;

    iDtLanguagesCodes = 0;

    iDtLanguagesCodes = new (ELeave)CArrayFixFlat<TInt>(10);

    iDtLanguagesCodes->AppendL(0); // This is the code for "Automatic"

    delete iDtLanguageItems;

    iDtLanguageItems = 0;

    iDtLanguageItems = iCoeEnv->ReadDesC16ArrayResourceL(

        R_DISPLAY_TEXT_LANGUAGE_SETTING_PAGE_LBX);

    //This is for display text language

    iModel->GetLanguagesFromPtiL( systemEpocLanguageCodes,

                                  iDtLanguagesCodes, iDtLanguageItems );

    CleanupStack::PopAndDestroy(); // systemEpocLanguageCode

    // Input Text Language Constrution

    iWtLanguagesCodes = new(ELeave)CArrayFixFlat<TInt>(10);

    iWtLanguageItems = new(ELeave)CDesCArrayFlat(10);

    //This is for input text language

    iModel->GetLanguagesFromPtiL( NULL, iWtLanguagesCodes, iWtLanguageItems );

    //Number modes

    iAHNumberModeItems = iCoeEnv->ReadDesC16ArrayResourceL(

        R_AH_DEFAULT_INPUT_METHOD_LBX );

    iHindiNumberModeItems = iCoeEnv->ReadDesC16ArrayResourceL(

        R_HI_DEFAULT_INPUT_METHOD_LBX );

    // Predictive Text Language Construction

    iOnOffItems = iCoeEnv->ReadDesC16ArrayResourceL(

        R_T9_ON_OFF_SETTING_PAGE_LBX );

    iOnOffNotAvailable =

        iCoeEnv->AllocReadResourceL( R_T9_ONOFF_NOT_AVAILABLE );

    //Japanese specific features

    iJapPredTxtOnOffItems = iCoeEnv->ReadDesC16ArrayResourceL(

        R_T9_ON_OFF_SETTING_PAGE_LBX );        

    iKeypressTimeoutItems = iCoeEnv->ReadDesC16ArrayResourceL( 

        R_KEYPRESS_TIMEOUT_SETTING_PAGE_LBX );

    iJapQwertyCommaItems = iCoeEnv->ReadDesC16ArrayResourceL( 

        R_JAP_QWERTY_COMMA_SETTING_PAGE_LBX );

    iJapQwertyPeriodItems = iCoeEnv->ReadDesC16ArrayResourceL( 

        R_JAP_QWERTY_PERIOD_SETTING_PAGE_LBX );

    iJapQwertyWidthOfSpaceItems = iCoeEnv->ReadDesC16ArrayResourceL( 

        R_JAP_QWERTY_WIDTH_FULL_HALF_SETTING_PAGE_LBX );

    iChiCangJieItems = iCoeEnv->ReadDesC16ArrayResourceL( 

        R_CHI_CANGJIE_SETTING_PAGE_LBX );

	// Word Autocompletion

	iPredictiveModeItems = iCoeEnv->ReadDesC16ArrayResourceL( 

        R_PREDICTIVE_MODE_SETTING_PAGE_LBX );

    iInputMethodItems = 0;

    CreateListBoxItemsL();

    }

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

// CGSLangContainer::CreateListBoxItemsL

//

//

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

//

void CGSLangContainer::CreateListBoxItemsL()

    {

    MakeDTLItemL();

    const TInt uiLang = iModel->LanguageL( CGSLangModel::EGSUiLanguage );

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

        ( uiLang == ELangUrdu || User::Language() == ELangUrdu ) || 

        (uiLang == ELangFarsi || User::Language() == ELangFarsi) && iElaf )

        {

        MakeAHNumberModeItemL();

        }

    if ( uiLang == ELangHindi || User::Language() == ELangHindi ||

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

        {

        MakeHindiNumberModeItemL();

        }

    // if Japanese language variant is flashed

    if ( FeatureManager::FeatureSupported( KFeatureIdJapanese ) )

        {

        MakeEngPredTxtItemL();

        MakeResetATOKDictionaryItemL();

        MakeJnpPredTxtItemL();

        MakeKeypressTimeoutItemL();

        if ( FeatureManager::FeatureSupported( KFeatureIdQwertyInput ) )

            {

            MakeJapQwertyItemL( EGSLangIdJQC );

            MakeJapQwertyItemL( EGSLangIdJQP );

            MakeJapQwertyItemL( EGSLangIdJQWSP );

            }

        }

    else

        {

        MakeITLItemL();    //because we don't need this item in japanese

        MakeT9LItemL();

#ifndef RD_INTELLIGENT_TEXT_INPUT

        MakePredictiveModeItemL();

#else

        MakePredictiveOptionsItemL();

#endif

        }

    const TInt inputLang = iModel->LanguageL( CGSLangModel::EGSInputLanguage );

    if( FeatureManager::FeatureSupported( KFeatureIdChinese ) &&

        ( inputLang == ELangPrcChinese || inputLang == ELangHongKongChinese ||

        inputLang == ELangTaiwanChinese ) )

        {

        MakeDIMItemL();

        }

    // check for input language even if it is done also in CheckDictionary...

    // CangJie is only supported for HK Chinese variant

    if ( iModel->DefaultInputMethodL() == ECangJie && 

            iModel->CheckCangjieSupportL( inputLang ) )

        {

        MakeCangJieItemL();

        }

    }

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

// CGSLangContainer::~CGSLangContainer

// Destructor.

//

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

//

CGSLangContainer::~CGSLangContainer()

    {

    if( iModel )

        {

        delete iModel;

        }

    if ( iDtLanguageItems )

        {

        delete iDtLanguageItems;

        }

    if ( iDtLanguagesCodes )

        {

        delete iDtLanguagesCodes;

        }

    if ( iWtLanguageItems )

        {

        delete iWtLanguageItems;

        }

    if ( iWtLanguagesCodes )

        {

        delete iWtLanguagesCodes;

        }

    if ( iAHNumberModeItems )

        {

        delete iAHNumberModeItems;

        }

    if ( iHindiNumberModeItems )

        {

        delete iHindiNumberModeItems;

        }

    if ( iInputMethodItems )

        {

        delete iInputMethodItems;

        }

    if ( iOnOffItems )

        {

        delete iOnOffItems;

        }

    if ( iOnOffNotAvailable )

        {

        delete iOnOffNotAvailable;

        }

    if ( iListboxItemArray )

        {

        delete iListboxItemArray;

        }

    if ( iJapPredTxtOnOffItems )

        {

        delete iJapPredTxtOnOffItems;

        }

    if ( iKeypressTimeoutItems )

        {

        delete iKeypressTimeoutItems;

        }

    if ( iJapQwertyCommaItems )

        {

        delete iJapQwertyCommaItems;

        }

    if ( iJapQwertyPeriodItems )

        {

        delete iJapQwertyPeriodItems;

        }

    if ( iJapQwertyWidthOfSpaceItems )

        {

        delete iJapQwertyWidthOfSpaceItems;

        }

    if ( iChiCangJieItems )

        {

        delete iChiCangJieItems;

        }

    delete iPredictiveModeItems;

    }

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

// CGSLangContainer::CountComponentControls

//

//

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

//

TInt CGSLangContainer::CountComponentControls() const

    {

    return 1;

    }

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

// CGSLangContainer::ComponentControl

//

//

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

//

CCoeControl* CGSLangContainer::ComponentControl( TInt /*aIndex*/ ) const

    {

    return iListBox;

    }

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

// CGSLangContainer::UpdateListBoxL

//

//

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

//

void CGSLangContainer::UpdateListBoxL( TInt aFeatureId )

    {

    const TInt uiLang = iModel->LanguageL( CGSLangModel::EGSUiLanguage );

    switch ( aFeatureId )

        {

        case EGSLangIdDTL:

            {

            MakeDTLItemL();

            if ( uiLang != 0 )

                {

                iUpdateITL = ETrue;

                }

            }

            break;

        case EGSLangIdITL:

            if ( !FeatureManager::FeatureSupported( KFeatureIdJapanese ) )

                {

                MakeITLItemL();

                }

            break;

        case EGSLangAHNumberMode:

            if( iElaf )

                {

                MakeAHNumberModeItemL();

                }

            break;

        case EGSLangHindiNumberMode:

            if ( uiLang == ELangHindi || User::Language() == ELangHindi ||

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

                {

                MakeHindiNumberModeItemL();

                }

            break;

        case EGSLangIdT9L:

            if ( !FeatureManager::FeatureSupported( KFeatureIdJapanese ) )

                {

                MakeT9LItemL();

#ifdef RD_INTELLIGENT_TEXT_INPUT

                MakePredictiveOptionsItemL();

#else

                MakePredictiveModeItemL();

#endif

                }

            break;

        case EGSLangIdEPT:

            if ( FeatureManager::FeatureSupported( KFeatureIdJapanese ) )

                {

                MakeEngPredTxtItemL();

                }

            break;

        case EGSLangIdResetAtokDict:

            if ( FeatureManager::FeatureSupported( KFeatureIdJapanese ) )

                {

                MakeResetATOKDictionaryItemL();

                }

            break;

        case EGSLangIdJPT:

            if ( FeatureManager::FeatureSupported( KFeatureIdJapanese ) )

                {

                MakeJnpPredTxtItemL();

                }

            break;

        case EGSLangIdKT:

            if ( FeatureManager::FeatureSupported( KFeatureIdJapanese ) )

                {

                MakeKeypressTimeoutItemL();

                }

            break;

        case EGSLangIdJQC:

        case EGSLangIdJQP:

        case EGSLangIdJQWSP:

            if ( FeatureManager::FeatureSupported( KFeatureIdJapanese ) &&

                 FeatureManager::FeatureSupported( KFeatureIdQwertyInput ) )

                {

                MakeJapQwertyItemL( aFeatureId );

                }

            break;

        case EGSLangIdDIM:

            if ( FeatureManager::FeatureSupported( KFeatureIdChinese ) )

                {

                MakeDIMItemL();

                }

            break;

        case EGSLangIdCangJie:

            //Check for support is not done here assuming it is checked

            //before calling this method with this ID.

            if ( iModel->DefaultInputMethodL() == ECangJie )

                {

                MakeCangJieItemL();

                }

            break;

        case EGSLangIdPredictiveMode:

        	if ( !FeatureManager::FeatureSupported( KFeatureIdJapanese ) )

                {

#ifndef RD_INTELLIGENT_TEXT_INPUT

        		MakePredictiveModeItemL();

#else

        		MakePredictiveOptionsItemL();

#endif

        		}

        default:

            break;

        }

    // Currently selected feature id

    const TInt currentlySelectedFeature = iListboxItemArray->CurrentFeature();

    //Make a list item visible based on feature ID

    MakeListItemVisibleL( aFeatureId, currentlySelectedFeature );

    // Update the listbox

    iListBox->HandleItemAdditionL();

    }

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

// CGSLangContainer::MakeDTLItemL

//

//

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

//

void CGSLangContainer::MakeDTLItemL()

    {

    // Get the item from the listbox model and then dynamically set

    // its caption

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

    TPtr ptrBuffer ( dynamicText->Des() );

    const TInt uiLanguage = iModel->LanguageL( CGSLangModel::EGSUiLanguage );

    TInt count = iDtLanguagesCodes->Count();

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

        {

        if ( ( *iDtLanguagesCodes )[ index ] == uiLanguage )

            {

            ptrBuffer = ( *iDtLanguageItems )[ index ];

            break;

            }

        }

    if ( !ptrBuffer.Length() && iDtLanguageItems->Count() > 0 )

        {

        ptrBuffer = ( *iDtLanguageItems )[0];

        }

    // Finally, set the dynamic text

    iListboxItemArray->SetDynamicTextL( EGSLangIdDTL, ptrBuffer );

    CleanupStack::PopAndDestroy( dynamicText );

    // And add to listbox

    iListboxItemArray->SetItemVisibilityL( EGSLangIdDTL,

        CGSListBoxItemTextArray::EVisible );

    }

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

// CGSLangContainer::MakeITLItemL

//

//

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

//

void CGSLangContainer::MakeITLItemL()

    {

    // Dynamic text not wanted in case we have dual language suppport

#ifndef FF_DUAL_LANGUAGE_SUPPORT

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

    TPtr ptrBuffer ( dynamicText->Des() );

    // Get Input Language code

    const TInt inputLanguage = iModel->LanguageL( CGSLangModel::EGSInputLanguage );

    const TInt uiLanguage = iModel->LanguageL( CGSLangModel::EGSUiLanguage );

    TInt count = iWtLanguagesCodes->Count();

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

        {

        if ( !iUpdateITL )

            {

            if ( ( *iWtLanguagesCodes )[index] == inputLanguage )

                {

                ptrBuffer = ( *iWtLanguageItems )[index];

                break;

                }

            }

        else

            {

            if ( ( *iWtLanguagesCodes )[index] == uiLanguage &&

                 uiLanguage != 0 ) // 'Automatic' = 0

                {

                iModel->SetLanguageL( CGSLangModel::EGSInputLanguage,

                                    ( *iWtLanguagesCodes )[index] );

                ptrBuffer = ( *iWtLanguageItems )[index];

                break;

                }

            }

        }

    iUpdateITL = EFalse;

    if ( !ptrBuffer.Length() && iWtLanguageItems->Count() > 0 )