/*

* Copyright (c) 2002-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 GSPenInputPlugin.

*

*/

#include <gspeninputpluginrsc.rsg>

#include <featmgr.h>

#include <hal.h>

#include <PtiEngine.h>

#include <AknFepGlobalEnums.h>

#include <PtiDefs.h>

#include <settingsinternalcrkeys.h>

#include <peninputpluginutils.h>

#include <AknFepInternalCRKeys.h>

#include <AvkonInternalCRKeys.h>

#include <aknfeppeninputenums.h>

#include <apgwgnam.h>

#include <eikapp.h>

#include <eikenv.h>

#include <eikappui.h>

#include <featmgr.h>

#include <peninputsettingappui.h>

#include "gspeninputmodel.h"

#include "gspeninputcontainer.h"

#include "truisupportedlanguageid.h"

#include "peninputpluginutils.h"

// CONSTANTS 

const TInt KTwipPerInch = 1440 * 1440;

const TInt KMidLeftBounday = 165;

const TInt KHigLeftBounday = 225;

const TInt KGSLanguageMask = 0x03FF;

const TInt KISOCodeLength = 2;

const TUid KUidtruiApp = { 0x2000B104 };

const TUid KUidPenInputSettingApp = { 0x2001959B };

const TInt KFepChineseInputModeLength = 10;

_LIT(KLeftBracket, "(" );

_LIT(KRightBracket, ")" );

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

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

// Constructor

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

//

CGSRepositoryWatcher* CGSRepositoryWatcher::NewL(MGsCenRepNotifyHandlerCallback* aOwner,

                                                 CRepository* aRepository,

                                                 TUid aRepositoryUid )

    {

    CGSRepositoryWatcher* self = new (ELeave) CGSRepositoryWatcher(aOwner, aRepository, aRepositoryUid);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// Destructor

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

//

CGSRepositoryWatcher::~CGSRepositoryWatcher()

    {

    if(iNotifyHandler)

        {

        iNotifyHandler->StopListening();

        delete iNotifyHandler;

        }

    }

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

// Constructor

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

//

CGSRepositoryWatcher::CGSRepositoryWatcher(MGsCenRepNotifyHandlerCallback* aOwner,

                                           CRepository* aRepository,

                                           TUid aRepositoryUid)

    :iOwner(aOwner), iRepository(aRepository), iRepositoryUid(aRepositoryUid)

    {

    }

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

// Constructor

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

//

void CGSRepositoryWatcher::ConstructL()

    {

    iNotifyHandler = CCenRepNotifyHandler::NewL(*this, *iRepository);

    iNotifyHandler->StartListeningL();

    }

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

// Notify call back function

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

//

void CGSRepositoryWatcher::HandleNotifyInt(TUint32 aKey, TInt aNewValue)

    {

    if (iOwner)

        {

        iOwner->HandleNotifyInt(iRepositoryUid, aKey, aNewValue);

        }

    }

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

// Notify call back function

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

//

void CGSRepositoryWatcher::HandleNotifyGeneric(TUint32 aId)

    {

    if (iOwner)

        {

        iOwner->HandleNotifyInt(iRepositoryUid, aId, 0);

        } 

    }

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

// Constructor

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

//

CGSPenInputModel* CGSPenInputModel::NewL(MGsCenRepNotifyHandlerCallback* aOwner)

    {

    CGSPenInputModel* self = new (ELeave) CGSPenInputModel(aOwner);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// Constructor

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

//

CGSPenInputModel* CGSPenInputModel::NewL()

    {

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// Constructor

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

//

CGSPenInputModel::CGSPenInputModel(MGsCenRepNotifyHandlerCallback* aOwner)

    : iOwner(aOwner), iInputLanguage(ELangTest), iSpeed(0), 

      iWidth(0), iColor(0), 

      iLastChineseFindMethodItem(-1), 

      iGuideLine(ETrue), iIsRecognitionWithDictionary(ETrue), iInputMode(ELatin)

   {

   }

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

// Constructor

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

//

CGSPenInputModel::CGSPenInputModel()

    : iOwner(NULL), iInputLanguage(ELangTest), iSpeed(0), iWidth(0),  

      iColor(0),  

      iLastChineseFindMethodItem(-1), 

      iGuideLine(ETrue), iIsRecognitionWithDictionary(ETrue),iInputMode(ELatin)

   {

   }

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

// Constructor

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

//

void CGSPenInputModel::ConstructL()

    {

    InitTrailWidthArrayL();    

    InitWritingSpeedArray();

    FeatureManager::InitializeLibL();

    iPtiEngine = CPtiEngine::NewL();

    InitializeCentralRepositoriesL();

    iConnectErr = iPenInputServer.Connect();

    }

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

// Initializes writing speed array

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

//

void CGSPenInputModel::InitWritingSpeedArray()

    {

    iWritingSpeedValue[0] = EPenInputWritingSpeedVeryFast;

    iWritingSpeedValue[1] = EPenInputWritingSpeedFast;

    iWritingSpeedValue[2] = EPenInputWritingSpeedNormal;

    iWritingSpeedValue[3] = EPenInputWritingSpeedSlow;

    iWritingSpeedValue[4] = EPenInputWritingSpeedVerySlow;

    }

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

// Initializes pen trail width array

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

//

void CGSPenInputModel::InitTrailWidthArrayL()

    {

    TInt twipX;

    TInt twipY;

    TInt pixelX;

    TInt pixelY;

    HAL::Get(HALData::EDisplayXTwips, twipX);

    HAL::Get(HALData::EDisplayYTwips, twipY);

    HAL::Get(HALData::EDisplayXPixels, pixelX);

    HAL::Get(HALData::EDisplayYPixels, pixelY);

    if (twipX * twipY <= 0 || pixelX * pixelY <= 0)

        {

        User::Leave(KErrNotSupported);  

        }

    TInt dpi = (pixelX * pixelY) / ((twipX * twipY) * KTwipPerInch);

    if (dpi < KMidLeftBounday)

        {

        dpi = EDPILow;

        }

    else if (dpi >= KMidLeftBounday && dpi < KHigLeftBounday)

        {

        dpi = EDPIMiddle;

        }

    else

        {

        dpi = EDPIHigh;

        }

    switch(dpi)

        {

        case EDPILow:

            {

            InitLowDPI();

            }

            break;

        case EDPIMiddle:

            {

            InitMiddleDPI();

            }

            break;

        case EDPIHigh:

            {

            InitHighDPI();

            }

            break;

        default:

            {

            InitLowDPI();    

            break;

            }          

        }

    }

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

// Initializes low dpi array

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

//

void CGSPenInputModel::InitLowDPI()

    {

    iTrailWidthValue[0] = 2;

    iTrailWidthValue[1] = 3;

    iTrailWidthValue[2] = 4;

    }

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

// Initializes middle dpi array

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

//

void CGSPenInputModel::InitMiddleDPI()

    {

    iTrailWidthValue[0] = 3;

    iTrailWidthValue[1] = 4;

    iTrailWidthValue[2] = 6;

    }

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

// Initializes high dpi array

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

//

void CGSPenInputModel::InitHighDPI()

    {

    iTrailWidthValue[0] = 3;

    iTrailWidthValue[1] = 4;

    iTrailWidthValue[2] = 8;

    }

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

// Destructor

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

//

CGSPenInputModel::~CGSPenInputModel()

    {

    delete iPersonalizationWatcher;

    delete iPersonalizationRepository;

    delete iAknfepWatcher;

    delete iAknfepRepository;

    delete iAknWatcher;

    delete iAknRepository;

    FeatureManager::UnInitializeLib();

    delete iPtiEngine;

    iPenInputServer.Close();

    }

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

// Initializes Repository

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

//

void CGSPenInputModel::InitializeCentralRepositoriesL()

    {

    iPersonalizationRepository = CRepository::NewL(KCRUidPersonalizationSettings);

    iPersonalizationWatcher = CGSRepositoryWatcher::NewL(iOwner, iPersonalizationRepository,KCRUidPersonalizationSettings);

    iAknfepRepository = CRepository::NewL(KCRUidAknFep);

    iAknfepWatcher = CGSRepositoryWatcher::NewL(iOwner, iAknfepRepository,KCRUidAknFep);

    iAknRepository = CRepository::NewL(KCRUidAvkon);

    iAknWatcher = CGSRepositoryWatcher::NewL(iOwner, iAknRepository,KCRUidAvkon);

    }

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

// Current input language name in list box item    

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

//

void CGSPenInputModel::InputLanguage(TDes& aLanguage) 

    {

    iAknfepRepository->Get(KAknFepInputTxtLang, iInputLanguage);

    iPtiEngine->GetLocalizedLanguageName(iInputLanguage & KGSLanguageMask,

                                         aLanguage);

    }

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

// Current input languageID 

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

//

TInt CGSPenInputModel::InputLanguage() 

    {

    iAknfepRepository->Get(KAknFepInputTxtLang, iInputLanguage);

    return iInputLanguage; 

    }

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

// Get languages from ptiengine    

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

//

void CGSPenInputModel::GetLanguagesFromPtiL(TBool aISOCode, CDesCArray* aLanguageNames)

    {

    InputLanguage();    

    RArray<TInt> languageCodeArray;

    iPtiEngine->GetAvailableLanguagesL(languageCodeArray);

    const TInt count = languageCodeArray.Count();

    TInt langId = 0;

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

    TBuf<KISOCodeLength>  isoCodeName;

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

        {

        langId = languageCodeArray[index];

        TPtr ptrToBuffer(buffer->Des());

        iPtiEngine->GetLocalizedLanguageName(langId & KGSLanguageMask,

                                             ptrToBuffer);

        //AdjustLanguageName(langId & KGSLanguageMask, ptrToBuffer); 

        if (aISOCode)

            {

            if (AknPenInputUtils::GetISOLanguageCode(TLanguage(langId), isoCodeName))

                {

                ptrToBuffer.Append(KLeftBracket);

                ptrToBuffer.Append(isoCodeName);

                ptrToBuffer.Append(KRightBracket);

                }

            }

        aLanguageNames->AppendL(ptrToBuffer);

        if (iInputLanguage == langId)

            {

            iLanguageIndex = index;   

            }

        ptrToBuffer.Zero();

        }

    CleanupStack::PopAndDestroy(buffer);

    languageCodeArray.Reset();

    languageCodeArray.Close(); 

    }

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

// Get Popup Query languages from ptiengine    

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

//

void CGSPenInputModel::GetPopupQuerylanguagesFromPtiL(CDesCArray* aLanguageNames)    

    {

    RArray<TInt> languageCodeArray;

    iPtiEngine->GetAvailableLanguagesL(languageCodeArray);

    // Item format should be "<icon_index>\t<item_text>"

    _LIT( KIconIndexSelected, "0\t" );

    _LIT( KIconIndexNotSelected, "\t" );// No icon

    MPtiLanguage* lang = NULL;

    TBuf<KISOCodeLength>  isoCodeName;

    for (TInt index = 0; index < languageCodeArray.Count(); index ++)

        {

        lang = iPtiEngine->GetLanguage(languageCodeArray[index]);

        if (!lang)

            {

            User::Leave(KErrCorrupt);

            }

        // Buffer should contain both tabulator string and localized name:

        HBufC* langStrBuf = HBufC::NewL(lang->LocalizedName().Length() + 7);

        CleanupStack::PushL(langStrBuf);

        TPtr langStrPtr = langStrBuf->Des();

        // If language is current language - use selected icon in lbx:

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

            {

            langStrPtr.Append(KIconIndexSelected);

            iLanguageIndex = index;

            }

        else

            {

            langStrPtr.Append(KIconIndexNotSelected);    

            }

        langStrPtr.Append(lang->LocalizedName());

        //AdjustLanguageName(lang->LanguageCode(), langStrPtr); 

        /*if (AknPenInputUtils::GetISOLanguageCode(TLanguage(lang->LanguageCode()), 

                                                 isoCodeName))

            {

            langStrPtr.Append(KLeftBracket);

            langStrPtr.Append(isoCodeName);

            langStrPtr.Append(KRightBracket);

            }*/

        aLanguageNames->AppendL(langStrPtr);

        CleanupStack::PopAndDestroy(langStrBuf);

        }

    languageCodeArray.Reset();

    languageCodeArray.Close();     

    }

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

// Store input language to Repository

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

//

void CGSPenInputModel::SetInputLanguageL()

    {

    RArray<TInt> languageCodeArray;

    iPtiEngine->GetAvailableLanguagesL(languageCodeArray);

    const TInt count = languageCodeArray.Count();

    if (iLanguageIndex <= count)

        {

        iInputLanguage = languageCodeArray[iLanguageIndex];

        iAknfepRepository->Set(KAknFepInputTxtLang, iInputLanguage);    

        }

    languageCodeArray.Reset();

    languageCodeArray.Close();    

    // Remember which chinese language variant was used 

    // for the chinese find method setting

    TUint key = ChineseFindMethodCRKey();

    if(key != iLastChineseFindMethodItem)

        {

        iAknRepository->Set(KAknAdaptiveSearchLastChinese, (int)key);

        iLastChineseFindMethodItem = key;

        }

    }

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

// Current writing speed index in list box item

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

//

TInt CGSPenInputModel::WritingSpeed() 

    {

    iPersonalizationRepository->Get(KSettingsWritingSpeed, iSpeed);

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

        {

        if (iSpeed == iWritingSpeedValue[index])

            {

            return index;            

            }

        }

    iSpeed = iWritingSpeedValue[0];

    iPersonalizationRepository->Set(KSettingsWritingSpeed, iSpeed);

    return 0;

    }

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