/*

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

*

*/

// Includes

#include "GSLangPlugin.h"

#include "GSLangContainer.h"

#include "GSLangModel.h"

#include <gsfwviewuids.h>

#include <gslistbox.h>

#include <gsprivatepluginproviderids.h>

#include <AknDateFormatUtils.h>

#include <AknFepGlobalEnums.h>  // EPinyin

#include <aknnotewrappers.h>

#include <aknradiobuttonsettingpage.h>

#include <aknsettingpage.h>

#include <akntextsettingpage.h>

#include <aknViewAppUi.h>

#include <AknWaitDialog.h>

#include <eikapp.h>

#include <featmgr.h>

#include <hlplch.h> // HlpLauncher

#include <PSVariables.h>

#include <PtiEngine.h>

#include <StringLoader.h>

#include <syslangutil.h>        // Display UI language

#include <ctsydomainpskeys.h>

#include <satdomainpskeys.h>

#include <e32property.h>

#ifdef RD_INTELLIGENT_TEXT_INPUT

#include "PredictiveSettingDialog.h"

#include <akntitle.h>

#ifdef FF_DUAL_LANGUAGE_SUPPORT

#include "DualLanguageDialog.h"

#endif

#include <aknnotedialog.h>          //CAknNoteDialog 

#include <AvkonInternalCRKeys.h> 

#endif

#include <gslangplugin.mbg>

#ifndef RD_STARTUP_CHANGE

    #include <sysstartup.h>         // Startup reasons

#else

    #include <starterclient.h>      // Startup reasons

#endif // RD_STARTUP_CHANGE

// Constants

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

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

// CGSLangPlugin::CGSLangPlugin()

// Constructor

//

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

//

CGSLangPlugin::CGSLangPlugin():

    iCascadeOptionsOpen(EFalse),

    iDialog(NULL)

    {

    }

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

// CGSLangPlugin::~CGSLangPlugin()

// Destructor

//

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

//

CGSLangPlugin::~CGSLangPlugin()

    {

    FeatureManager::UnInitializeLib();

    if( iContainer )

        {

        AppUi()->RemoveFromViewStack( *this, iContainer );

        delete iContainer;

        }

    if(iDialog)

        {

       delete iDialog;

        }

#ifdef RD_INTELLIGENT_TEXT_INPUT    

#ifdef __ITI_VIRTUAL_TOUCH_FIRST_GENERATION_SUPPORT__       

    if (iKeyboardLayoutStatusSubscriber)

        {

        iKeyboardLayoutStatusSubscriber->StopSubscribe();

        }

    iKeyboardLayoutStatusProperty.Close();

    delete iKeyboardLayoutStatusSubscriber;     

#endif    

#endif    

    }

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

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

// Symbian OS two-phased constructor

// (other items were commented in a header).

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

//

void CGSLangPlugin::ConstructL()

    {

    FeatureManager::InitializeLibL();

    OpenLocalizedResourceFileL( KGSLangPluginResourceFileName,

                                iResourceLoader );

    BaseConstructL( R_GS_LANG_VIEW );

#ifdef RD_INTELLIGENT_TEXT_INPUT

#ifdef __ITI_VIRTUAL_TOUCH_FIRST_GENERATION_SUPPORT__   

    //Attach the P&S property to the keyboardlayout and subscribe to the P&S framework

    // for any keyboard layout change.

    User::LeaveIfError(iKeyboardLayoutStatusProperty.Attach(KCRUidAvkon, KAknKeyBoardLayout));    

    iKeyboardLayoutStatusSubscriber = new (ELeave) CSubscriber(

                                         TCallBack(HandleKeyboardLayoutChangeNotification, this), 

                                         iKeyboardLayoutStatusProperty);    

    iKeyboardLayoutStatusSubscriber->SubscribeL();

#endif

#endif 

    }

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

// CGSLangPlugin::NewL()

// Static constructor

//

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

//

CGSLangPlugin* CGSLangPlugin::NewL( TAny* /*aInitParams*/ )

    {

    CGSLangPlugin* self = new(ELeave) CGSLangPlugin();

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// CGSLangPlugin::Id

//

//

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

//

TUid CGSLangPlugin::Id() const

    {

    return KGSLangPluginUID;

    }

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

// CGSLangPlugin::HandleClientRectChange

//

//

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

//

void CGSLangPlugin::HandleClientRectChange()

    {

    if ( iContainer )

        {

        iContainer->SetRect( ClientRect() );

        }

    }

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

// CGSLangPlugin::DoActivateL

//

//

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

//

void CGSLangPlugin::DoActivateL( const TVwsViewId& aPrevViewId,

                                 TUid aCustomMessageId,

                                 const TDesC8& aCustomMessage )

    {

    CGSBaseView::DoActivateL( aPrevViewId, aCustomMessageId, aCustomMessage );

    }

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

// CGSLangPlugin::DoDeactivate

//

//

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

//

void CGSLangPlugin::DoDeactivate()

    {

    CGSBaseView::DoDeactivate();

    }

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

// CGSLangPlugin::HandleCommandL

//

//

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

//

void CGSLangPlugin::HandleCommandL( TInt aCommand )

    {

    switch ( aCommand )

        {

        case EGSMSKCmdAppChange:

            HandleListBoxSelectionL();

            break;

        case EGSCmdAppChange:

            if ( Container()->CurrentFeatureId() == EGSLangIdT9L )

                {

#ifdef RD_INTELLIGENT_TEXT_INPUT

                // Launch Predictive mode setting page if >1 keyboards available on device

                // Otherwise just change the setting value for the only keyboard

                ShowITIMultiSettingPageL(ETrue);

#else

                // If EGSLangIdT9L is selected, change T9

                // setting using setting page.

                Container()->Model()->ChangePredictiveOnOffSettingL(

                    ETrue,

                    CGSLangModel::EGSLangOther );

#endif

                }

            else if( Container()->CurrentFeatureId() == EGSLangIdEPT )

                {

                // If EGSLangIdEPT is selected, change T9

                // setting using setting page.

                Container()->Model()->ChangePredictiveOnOffSettingL(

                    ETrue,

                    CGSLangModel::EGSLangOther );

                }

            else if( Container()->CurrentFeatureId() == EGSLangIdJPT )

                {

                Container()->Model()->ChangePredictiveOnOffSettingL(

                    ETrue,

                    CGSLangModel::EGSLangJapanese );

                }

            else if( Container()->CurrentFeatureId() == EGSLangIdJQC )

                {

                ChangeJapQwertySettingL( EGSJapQwertyFlagComma,

                                         EGSLangIdJQC, ETrue );

                }

            else if( Container()->CurrentFeatureId() == EGSLangIdJQP )

                {

                ChangeJapQwertySettingL( EGSJapQwertyFlagPeriod,

                                         EGSLangIdJQP, ETrue );

                }

            else if( Container()->CurrentFeatureId() == EGSLangIdJQWSP )

                {

                ChangeJapQwertySettingL( EGSJapQwertyFlagSpaceFullWidth,

                                         EGSLangIdJQWSP, ETrue );

                }

            else if ( Container()->CurrentFeatureId() == EGSLangIdPredictiveMode )

            	{

#ifndef RD_INTELLIGENT_TEXT_INPUT

               if( Container()->Model()->CheckAutoWordCompletionSupportL() )

                   {

            	   ShowPredictiveModeSettingPageL( ETrue );

            	   }

#endif 

           	 	}

#ifdef RD_INTELLIGENT_TEXT_INPUT

            else if ( Container()->CurrentFeatureId() == EGSLangIdPredictiveOptions )

                {

                // Show full ITI predictive settings list

                ShowPredictiveSettingListL();

                }

#endif // RD_INTELLIGENT_TEXT_INPUT

           	else

                {

                HandleListBoxSelectionL();

                }

            break;

        case EAknSoftkeyBack:

            //In 5.0 "Language" settings were moved from Psln to Device view

            #ifdef RD_CONTROL_PANEL //For S60 5.0

		        AppUi()->ActivateLocalViewL( KGSGenPluginUid );

            #else //RD_CONTROL_PANEL 

            AppUi()->ActivateLocalViewL( KGSPrslnPluginUid );

			#endif //RD_CONTROL_PANEL

            break;

        case EAknCmdHelp:

            {

            if( FeatureManager::FeatureSupported( KFeatureIdHelp ) )

                {

                HlpLauncher::LaunchHelpApplicationL(

                    iEikonEnv->WsSession(), AppUi()->AppHelpContextL() );

                }

            break;

            }

        default:

            AppUi()->HandleCommandL( aCommand );

            break;

        }

    }

// ========================= From CGSPluginInterface ==================

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

// CGSLangPlugin::GetCaptionL

//

//

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

//

void CGSLangPlugin::GetCaptionL( TDes& aCaption ) const

    {

    HBufC* result = StringLoader::LoadL( R_GS_LANG_PLUGIN_CAPTION );

    aCaption.Copy( *result );

    delete result;

    }

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

// CGSLangPlugin::PluginProviderCategory

//

//

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

//

TInt CGSLangPlugin::PluginProviderCategory() const

    {

    //This plugin is created by 3rd party.

    return KGSPluginProviderInternal;

    }

// ========================= From CGSBaseView ==================

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

// CGSLangPlugin::NewContainerL

//

//

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

//

void CGSLangPlugin::NewContainerL()

    {

    iContainer = new(ELeave) CGSLangContainer;

    }

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

// CGSLangPlugin::HandleListBoxSelectionL

//

//

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

//

void CGSLangPlugin::HandleListBoxSelectionL()

    {

    const TInt currentFeatureId = Container()->CurrentFeatureId();

    switch ( currentFeatureId )

        {

        case EGSLangIdDTL:

            ShowLanguageSelectionSettingPageL();

            break;

        case EGSLangIdITL:

#ifdef RD_INTELLIGENT_TEXT_INPUT

#ifdef FF_DUAL_LANGUAGE_SUPPORT

            TInt keyboardLayout = 0;

            RProperty::Get(KCRUidAvkon, KAknKeyBoardLayout, keyboardLayout);

            TPtiKeyboardType layout = (TPtiKeyboardType)keyboardLayout;            

            // Currently dual language feature would work correctly for ITUT and Half Qwerty products 

            // Hence the dual language settings should also be displayed only for ITUT and Halfqwerty products

            if(layout == EPtiKeyboard12Key || layout == EPtiKeyboardHalfQwerty )

                {

	            // Show Dual language selection setting list

	            /* In Chinese/Japanese language variant,if there are more than one languages supporting dual language feature,

	            display writing language setting view in which Primary and Secondary Languages can be selected from the list.

	            In Chinese language variant,if there is only one language supporting dual language feature, 

	            no need to display the Writing language view which contains Primary and Secondary Language. 

	            Instead we can display the Writing language list directly to the user;from which the user can select the writing language*/

		            if ( FeatureManager::FeatureSupported( KFeatureIdJapanese ) ||  FeatureManager::FeatureSupported( KFeatureIdChinese ) )

		                {		                

		                CPtiEngine* ptiEngine = CPtiEngine::NewL();

		                CleanupStack::PushL( ptiEngine );

		                CArrayFixFlat<TInt>* languages = new( ELeave )CArrayFixFlat<TInt>( 10 );

		                CleanupStack::PushL( languages );

		                ptiEngine->GetAvailableLanguagesL( languages );

		                TInt count = languages->Count();  

		                TInt noLangSupportWesternPred = count; 

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

		                    {      

		                    const TInt langCode = languages->At(index);

		                    if (langCode == ELangTaiwanChinese ||

		                       langCode == ELangHongKongChinese ||

		                       langCode == ELangPrcChinese ||

		                       langCode == ELangJapanese ||

		                       langCode == ELangKorean )

		                        {

		                        noLangSupportWesternPred--;

		                        }            

		                    }                               

		                CleanupStack::PopAndDestroy(languages);

		                CleanupStack::PopAndDestroy(ptiEngine);

		                if( noLangSupportWesternPred > 1 )

		                    {

		                    ShowDualInputLanguageSettingListL();

		                    }

		                else

	                    ShowInputSelectionSettingPageL();

	                  }

	            	else            

	                	ShowDualInputLanguageSettingListL();

								}

	        	else 

            		ShowInputSelectionSettingPageL();

#else //FF_DUAL_LANGUAGE_SUPPORT

            ShowInputSelectionSettingPageL();

#endif //FF_DUAL_LANGUAGE_SUPPORT

#else //RD_INTELLIGENT_TEXT_INPUT

			ShowInputSelectionSettingPageL();

#endif //RD_INTELLIGENT_TEXT_INPUT

            break;

        case EGSLangAHNumberMode:

            if( iElaf )

                {

                ShowAHNumberModeSettingPageL();

                }

            break;

        case EGSLangHindiNumberMode:

            ShowHindiNumberModeSettingPageL();

            break;

        case EGSLangIdT9L:

            if ( !FeatureManager::FeatureSupported( KFeatureIdJapanese ) )

                {

#ifdef RD_INTELLIGENT_TEXT_INPUT

                // Launch Predictive mode setting page if >1 keyboards available on device

                // Otherwise just change the setting value for the only keyboard

                TInt keyboardLayout = 0;

                RProperty::Get(KCRUidAvkon, KAknKeyBoardLayout, keyboardLayout);

                TPtiKeyboardType layout = (TPtiKeyboardType)keyboardLayout;

                TBool isPredictionSupport = EFalse;

                switch(layout)

                {

                case EPtiKeyboardHalfQwerty:

                	isPredictionSupport = Container()->Model()->CheckT9FromPtiLForPredictionL((TPtiEngineInputMode)EPtiEngineHalfQwertyPredictive);

                  break;

                case EPtiKeyboardQwerty4x12:

                case EPtiKeyboardQwerty4x10:  

                case EPtiKeyboardQwerty3x11:

                case EPtiKeyboardCustomQwerty:

                	isPredictionSupport = Container()->Model()->CheckT9FromPtiLForPredictionL((TPtiEngineInputMode)EPtiEngineQwertyPredictive);

                  break;

                case EPtiKeyboardNone:

                case EPtiKeyboard12Key:

                	isPredictionSupport = Container()->Model()->CheckT9FromPtiLForPredictionL((TPtiEngineInputMode)EPtiEnginePredictive);

                  break;

                default:

                	isPredictionSupport = Container()->Model()->CheckT9FromPtiLForPredictionL((TPtiEngineInputMode)EPtiEnginePredictive);

                  break;    

                  }

                if (isPredictionSupport)

                	ShowITIMultiSettingPageL(EFalse);

#else

                //change setting without opening the setting page

                Container()->Model()->ChangePredictiveOnOffSettingL(

                    EFalse,

                    CGSLangModel::EGSLangOther );

#endif

                }

            break;

        case EGSLangIdEPT:

            if ( FeatureManager::FeatureSupported( KFeatureIdJapanese ) )

                {

                Container()->Model()->ChangePredictiveOnOffSettingL(

                    EFalse,

                    CGSLangModel::EGSLangOther );

                }

            break;

        case EGSLangIdResetAtokDict:

            if ( FeatureManager::FeatureSupported( KFeatureIdJapanese ) )

                {

                ResetATOKDictionaryL();

                }

            break;

        case EGSLangIdJPT:

            if ( FeatureManager::FeatureSupported( KFeatureIdJapanese ) )

                {

                Container()->Model()->ChangePredictiveOnOffSettingL(

                    EFalse,

                    CGSLangModel::EGSLangJapanese );

                }

            break;

        case EGSLangIdKT:

            if ( FeatureManager::FeatureSupported( KFeatureIdJapanese ) )

                {

                ShowKeypressTimeoutSettingPageL();

                }

            break;

        case EGSLangIdJQC:

            if ( FeatureManager::FeatureSupported( KFeatureIdJapanese ) &&

                 FeatureManager::FeatureSupported( KFeatureIdQwertyInput ) )

                {

                ChangeJapQwertySettingL( EGSJapQwertyFlagComma,

                                         currentFeatureId, EFalse );

                }

            break;

        case EGSLangIdJQP:

            if ( FeatureManager::FeatureSupported( KFeatureIdJapanese ) &&

                 FeatureManager::FeatureSupported( KFeatureIdQwertyInput ) )

                {

                ChangeJapQwertySettingL( EGSJapQwertyFlagPeriod,

                                         currentFeatureId, EFalse );

                }

            break;

        case EGSLangIdJQWSP:

            if ( FeatureManager::FeatureSupported( KFeatureIdJapanese ) &&

                 FeatureManager::FeatureSupported( KFeatureIdQwertyInput ) )

                {