/*
* Copyright (c) 2002-2004 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:
* CAknFepSharedDataInterface class
*
*/
#include <w32std.h>
#include <eikdef.h>
#include <eikenv.h>
#include <AknUtils.h>
#include "AknFepSharedDataInterface.h"
#include "AknFepManager.h"
#include <centralrepository.h>
#include <AknFepInternalCRKeys.h>
#ifdef RD_INTELLIGENT_TEXT_INPUT
#include <AknFepInternalPSKeys.h>
#include <AknFepGlobalEnums.h>
#include <PtiDefs.h>
#endif
#include <AvkonInternalCRKeys.h> // KAknQwertyInputModeActive
#include <settingsinternalcrkeys.h> //Pen related settings
#include <sensorplugindomaincrkeys.h> // KCRUidSensorSettings
#include <featmgr.h> // Feature Manager
// TODO: include CommonengineInternalCRKeys.h
const TUid KCRUidCommonEngineKeys = {0x1020503B};
const TUint32 KGSDisplayTxtLang = 0x00000001;
const TInt KJapHwrConversion = 0x0010;
#include <AknDef.h>
CAknFepSharedDataInterface* CAknFepSharedDataInterface::NewL(CAknFepManager* aFepManager)
{
CAknFepSharedDataInterface* self = new (ELeave) CAknFepSharedDataInterface(aFepManager);
CleanupStack::PushL(self);
self->ConstructL();
CleanupStack::Pop(); //self
return self;
}
CAknFepSharedDataInterface::~CAknFepSharedDataInterface()
{
delete iCommonEngineRepository;
delete iAknFepRepositoryWatcher;
delete iAknFepLocaleRepositoryWatcher;
delete iAknFepRepository;
delete iGsPenSettings;
delete iLocaleRepository;
delete iSensorRepository;
delete iThemeEffectsRepository;
if (iQwertyModeStatusSubscriber)
{
iQwertyModeStatusSubscriber->StopSubscribe();
}
#ifdef RD_INTELLIGENT_TEXT_INPUT
if (iKeyboardLayoutStatusSubscriber)
{
iKeyboardLayoutStatusSubscriber->StopSubscribe();
}
iKeyboardLayoutStatusProperty.Close();
delete iKeyboardLayoutStatusSubscriber;
#ifdef RD_SCALABLE_UI_V2
if ( iVirtualKeyboardLayoutStatusSubscriber )
{
iVirtualKeyboardLayoutStatusSubscriber->StopSubscribe();
}
delete iVirtualKeyboardLayoutStatusSubscriber;
iVirtualKeyboardLayoutStatusProperty.Close();
#endif
#endif
iQwertyModeStatusProperty.Close();
delete iQwertyModeStatusSubscriber;
}
TInt CAknFepSharedDataInterface::PredictiveTextOn()
{
TInt value = 0;
if (iAknFepRepository)
{
#ifdef RD_INTELLIGENT_TEXT_INPUT
TPtiKeyboardType layout = (TPtiKeyboardType)KeyboardLayout();
TInt temp = 0;
iAknFepRepository->Get(KAknFepPredTxtFlagExtension, temp);
switch(layout)
{
case EPtiKeyboardNone:
break;
case EPtiKeyboard12Key:
temp &= EKeyboardStyle12Key;
break;
case EPtiKeyboardHalfQwerty:
temp &= EKeyboardStyleHalfQwerty;
break;
case EPtiKeyboardQwerty4x12:
case EPtiKeyboardQwerty4x10:
case EPtiKeyboardQwerty3x11:
case EPtiKeyboardCustomQwerty:
temp &= EKeyboardStyleQwerty;
break;
default:
break;
}
value = ( temp ? 1 : 0);
#else
iAknFepRepository->Get(KAknFepPredTxtFlag, value);
#endif
}
return value;
}
TInt CAknFepSharedDataInterface::PredictiveTextJapaneseOn()
{
TInt value = 0;
if (iAknFepRepository)
{
iAknFepRepository->Get(KAknFepJapanesePredTxtFlag, value);
}
return value;
}
TInt CAknFepSharedDataInterface::InputMode()
{
TUint value = 0;
if (iAknFepRepository)
{
/* Teleca change begin, 03.07.2008 ssal
original code:
TPtrC filteredPtr(0,0);
iAknFepRepository->Get(KAknFepChineseInputMode, value);*/
_LIT(Kx, "x");
// This conversion is needed because KAknFepChineseInputMode cenrep key original type was 16bit int.
// now type is changed to string, so that it can accommodate bigger values like EHangul 0x16000.
TBuf<CAknFepManager::EMaximumFepWordLength> conversion;
iAknFepRepository->Get(KAknFepChineseInputMode, conversion);
TInt len = conversion.Find(Kx);
TLex lex;
if(len)
{
TPtrC ptr = conversion.Mid(len +1);
lex.Assign(ptr);
}
else
{
lex.Assign(conversion);
}
lex.Val(value, EHex);
/* Teleca change end, 04.06.2008 ssal */
}
return value;
}
void CAknFepSharedDataInterface::SetInputMode(TInt aInputMode)
{
if (iAknFepRepository)
{
/* Teleca change begin, 03.07.2008 ssal
original code:
iAknFepRepository->Set(KAknFepChineseInputMode, aInputMode);*/
// Please see the explanation on CAknFepSharedDataInterface::InputMode() method
TBuf<CAknFepManager::EMaximumFepWordLength> conversion;
conversion.Num(aInputMode, EHex);
iAknFepRepository->Set(KAknFepChineseInputMode, conversion);
/* Teleca change end, 04.06.2008 ssal */
}
}
TInt CAknFepSharedDataInterface::CangJieMode()
{
TInt value = 0;
if (iAknFepRepository)
{
iAknFepRepository->Get(KAknFepCangJieMode, value);
}
return value;
}
void CAknFepSharedDataInterface::SetCangJieMode(TInt aNewCangJieMode)
{
if (iAknFepRepository)
{
iAknFepRepository->Set(KAknFepCangJieMode, aNewCangJieMode);
}
}
TInt CAknFepSharedDataInterface::InputTextLanguage()
{
TInt value = 0;
if (iAknFepRepository)
{
iAknFepRepository->Get(KAknFepInputTxtLang, value);
}
return TLanguage(value);
}
void CAknFepSharedDataInterface::SetInputTextLanguage(TInt aValue)
{
if (iAknFepRepository)
{
iAknFepRepository->Set(KAknFepInputTxtLang, aValue);
}
// now inform all open apps of the switch
TWsEvent event;
event.SetType(KEikInputLanguageChange);
CEikonEnv::Static()->WsSession().SendEventToAllWindowGroups(event);
}
TInt CAknFepSharedDataInterface::DisplayLanguage()
{
TInt value = 0;
if (iCommonEngineRepository)
{
iCommonEngineRepository->Get(KGSDisplayTxtLang, value);
}
return TLanguage(value);
}
void CAknFepSharedDataInterface::SetPredictiveTextOn()
{
if (iAknFepRepository)
{
#ifdef RD_INTELLIGENT_TEXT_INPUT
TPtiKeyboardType layout = (TPtiKeyboardType)KeyboardLayout();
TInt value = 0;
iAknFepRepository->Get(KAknFepPredTxtFlagExtension, value);
switch(layout)
{
case EPtiKeyboardNone:
// No keyboard active, so don't change anything
break;
case EPtiKeyboard12Key:
value |= EKeyboardStyle12Key;
break;
case EPtiKeyboardHalfQwerty:
value |= EKeyboardStyleHalfQwerty;
break;
case EPtiKeyboardQwerty4x12:
case EPtiKeyboardQwerty4x10:
case EPtiKeyboardQwerty3x11:
case EPtiKeyboardCustomQwerty:
value |= EKeyboardStyleQwerty;
break;
default:
break;
}
iAknFepRepository->Set(KAknFepPredTxtFlagExtension, value);
// For backwards compatibility
if (value & EKeyboardStyle12Key)
{
iAknFepRepository->Set(KAknFepPredTxtFlag, 1);
}
#else
iAknFepRepository->Set(KAknFepPredTxtFlag, 1);
#endif
}
}
void CAknFepSharedDataInterface::ResetPredictiveTextOn()
{
if (iAknFepRepository)
{
#ifdef RD_INTELLIGENT_TEXT_INPUT
TPtiKeyboardType layout = (TPtiKeyboardType)KeyboardLayout();
TInt value = 0;
iAknFepRepository->Get(KAknFepPredTxtFlagExtension, value);
switch(layout)
{
case EPtiKeyboardNone:
// No keyboard active, so don't change anything
break;
case EPtiKeyboard12Key:
value &= ~EKeyboardStyle12Key;
break;
case EPtiKeyboardHalfQwerty:
value &= ~EKeyboardStyleHalfQwerty;
break;
case EPtiKeyboardQwerty4x12:
case EPtiKeyboardQwerty4x10:
case EPtiKeyboardQwerty3x11:
case EPtiKeyboardCustomQwerty:
value &= ~EKeyboardStyleQwerty;
break;
default:
break;
}
iAknFepRepository->Set(KAknFepPredTxtFlagExtension, value);
// For backwards compatibility
if (!(value & EKeyboardStyle12Key))
{
iAknFepRepository->Set(KAknFepPredTxtFlag, 0);
}
#else
iAknFepRepository->Set(KAknFepPredTxtFlag, 0);
#endif
}
}
void CAknFepSharedDataInterface::SetJapanesePredictiveTextOn()
{
if (iAknFepRepository)
{
iAknFepRepository->Set(KAknFepJapanesePredTxtFlag, 1);
}
}
void CAknFepSharedDataInterface::ResetJapanesePredictiveTextOn()
{
if (iAknFepRepository)
{
iAknFepRepository->Set(KAknFepJapanesePredTxtFlag, 0);
}
}
TInt CAknFepSharedDataInterface::PluginInputMode() const
{
TInt value = 0;
if (iAknFepRepository)
{
iAknFepRepository->Get(KAknFepLastUsedInput, value);
}
return value;
}
void CAknFepSharedDataInterface::SetPluginInputMode(TInt aDevice)
{
// Check validity of the input mode to be set.
if ( aDevice == EPluginInputModeItut )
{
__ASSERT_DEBUG( FeatureManager::FeatureSupported(
KFeatureIdVirtualItutInput ),
User::Panic( _L( "Wrong input mode - ITU-T" ), __LINE__ ) );
}
else if ( aDevice == EPluginInputModeFSQ )
{
__ASSERT_DEBUG( FeatureManager::FeatureSupported(
KFeatureIdVirtualFullscrQwertyInput ),
User::Panic( _L( "Wrong input mode - Landscape FSQ" ),
__LINE__ ) );
}
else if ( aDevice == EPluginInputModePortraitFSQ )
{
__ASSERT_DEBUG( FeatureManager::FeatureSupported(
KFeatureIdFfVirtualFullscrPortraitQwertyInput ),
User::Panic( _L( "Wrong input mode - Portrait FSQ" ),
__LINE__ ) );
}
else
{
// Do nothing.
}
if (iAknFepRepository)
{
iAknFepRepository->Set(KAknFepLastUsedInput, aDevice);
}
}
TInt CAknFepSharedDataInterface::PluginUILanguage() const
{
TInt value = 0;
if (iAknFepRepository)
{
//iAknFepRepository->Create(KAknFepLastUsedUILanguage, 0); //??
iAknFepRepository->Get(KAknFepLastUsedUILanguage, value);
}
return value;
}
void CAknFepSharedDataInterface::SetPluginUILanguage(TInt aLanguage)
{
if (iAknFepRepository)
{
iAknFepRepository->Set(KAknFepLastUsedUILanguage, aLanguage);
}
}
void CAknFepSharedDataInterface::SetDefaultNumberMode( TInt aMode, TInt aValue )
{
if (iLocaleRepository)
{
iLocaleRepository->Set(aMode, aValue);
}
}
TInt CAknFepSharedDataInterface::PenInputLanguage() const
{
TInt value = 0;
if (iAknFepRepository)
{
iAknFepRepository->Get(KAknFepInputTxtLang, value);
}
return value;
}
TInt CAknFepSharedDataInterface::ScrollLatinPredictiveCandidates() const
{
return iSharedDataScrollLatinPredictive;
}
TInt CAknFepSharedDataInterface::SpaceWithScrollRight() const
{
return iSharedDataSpaceWithScrollRight;
}
TInt CAknFepSharedDataInterface::EntersWithScrollDown() const
{
return iSharedDataEnterWithScrollDown;
}
TInt CAknFepSharedDataInterface::QwertyInputMode() //const
{
TInt value = 0;
iQwertyModeStatusProperty.Get(value);
return value;
}
#ifdef RD_INTELLIGENT_TEXT_INPUT
TInt CAknFepSharedDataInterface::KeyboardLayout() //const
{
return ActiveKeyboardType();
}
#ifdef FF_DUAL_LANGUAGE_SUPPORT
TInt CAknFepSharedDataInterface::InputTextLanguageSecondary()
{
TInt value = 0;
if (iAknFepRepository)
{
iAknFepRepository->Get(KAknFepInputTxtLangSecondary, value);
}
return TLanguage(value);
}
void CAknFepSharedDataInterface::SetInputTextLanguageSecondary(TInt aValue)
{
if (iAknFepRepository)
{
iAknFepRepository->Set(KAknFepInputTxtLangSecondary, aValue);
}
// 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);
}
#endif //FF_DUAL_LANGUAGE_SUPPORT
#endif
CAknFepSharedDataInterface::CAknFepSharedDataInterface(CAknFepManager* aFepManager)
{
iFepManager = aFepManager;
}
void CAknFepSharedDataInterface::ConstructL()
{
TInt ret = KErrNone;
TRAP(ret, iCommonEngineRepository = CRepository::NewL(KCRUidCommonEngineKeys));
TRAP(ret, iAknFepRepository = CRepository::NewL(KCRUidAknFep));
if (ret == KErrNone)
{
iAknFepRepositoryWatcher = CAknFepRepositoryWatcher::NewL(
KCRUidAknFep,
TCallBack(HandleRepositoryCallBack, this),
iAknFepRepository);
HandleHashKeySelectionChange();//we need read proactively before value changed,and we must sure the iAknFepRepository has been constructed
}
TRAP(ret, iLocaleRepository = CRepository::NewL( KCRUidLocaleSettings ));
if (ret == KErrNone)
{
iAknFepLocaleRepositoryWatcher = CAknFepRepositoryWatcher::NewL(
KCRUidLocaleSettings,
TCallBack(HandleLocaleRepositoryCallBack, this),
iLocaleRepository);
}
User::LeaveIfError(iQwertyModeStatusProperty.Attach(KCRUidAvkon, KAknQwertyInputModeActive));
#ifdef RD_INTELLIGENT_TEXT_INPUT
//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();
#ifdef RD_SCALABLE_UI_V2
User::LeaveIfError( iVirtualKeyboardLayoutStatusProperty.Attach
( KPSUidAknFep, KAknFepVirtualKeyboardType ) );
iVirtualKeyboardLayoutStatusSubscriber = new (ELeave) CSubscriber(
TCallBack( HandleVirtualKeyboardLayoutChangeNotification, this ),
iVirtualKeyboardLayoutStatusProperty );
iVirtualKeyboardLayoutStatusSubscriber->SubscribeL();
#endif // RD_SCALABLE_UI_V2
#endif
iQwertyModeStatusSubscriber = new (ELeave) CSubscriber(
TCallBack(QwertyModeChangeNotification, this),
iQwertyModeStatusProperty);
iQwertyModeStatusSubscriber->SubscribeL();
// Read read-only shared data settings.
if (iAknFepRepository)
{
iAknFepRepository->Get(KAknFepScrollLatinPredictive, iSharedDataScrollLatinPredictive);
iAknFepRepository->Get(KAknFepSpaceWithScrollRight, iSharedDataSpaceWithScrollRight);
iAknFepRepository->Get(KAknFepEnterWithScrollDown, iSharedDataEnterWithScrollDown);
}
TRAP(ret, iGsPenSettings = CRepository::NewL(KCRUidPersonalizationSettings));
TRAP(ret, iSensorRepository = CRepository::NewL( KCRUidSensorSettings ) );
TRAP(ret, iThemeEffectsRepository = CRepository::NewL( KCRUidThemes ));
}
TInt CAknFepSharedDataInterface::HashKeySelectionNotification(TAny* aObj)
{
if (aObj)
{
static_cast<CAknFepSharedDataInterface*>(aObj)->HandleHashKeySelectionChange();
return KErrNone;
}
else
{
return KErrArgument;
}
}
void CAknFepSharedDataInterface::HandleHashKeySelectionChange()
{
TInt value(0);
if (iAknFepRepository)
{
iAknFepRepository->Get(KAknFepHashKeySelection, value);
}
iHashKeySelectionInUse = value;
}
TInt CAknFepSharedDataInterface::InputModeChangeGSNotification(TAny* aObj)
{
if (aObj)
{
static_cast<CAknFepSharedDataInterface*>(aObj)->HandleInputModeGSChange();
return KErrNone;
}
else
{
return KErrArgument;
}
}
void CAknFepSharedDataInterface::HandleInputModeGSChange()
{
iFepManager->SetFlag(CAknFepManager::EFlagNewSharedDataInputMode);
}
TInt CAknFepSharedDataInterface::InputTextLangGSNotification(TAny* aObj)
{
if (aObj)
{
static_cast<CAknFepSharedDataInterface*>(aObj)->HandleInputTextLanguageGSChange();
return KErrNone;
}
else
{
return KErrArgument;
}
}
void CAknFepSharedDataInterface::HandleInputTextLanguageGSChange()
{
if( iFepManager->ActiveInputLanguage() != PenInputLanguage() )
{
iFepManager->SetFlag(CAknFepManager::EFlagNewSharedDataInputLanguage);
ESubVariantFlag subVariant = AknLayoutUtils::SubVariant();
if((AknLayoutUtils::Variant() == EApacVariant)
&& ((subVariant == EPrcSubVariant)
|| (subVariant == EHongKongSubVariant)
|| (subVariant == ETaiwanSubVariant)))
{
iFepManager->SetFlag(CAknFepManager::EFlagNewSharedDataInputMode);
}
iFepManager->SetActiveInputLanguage( PenInputLanguage() );
}
}
TInt CAknFepSharedDataInterface::PredictiveTextSettingChangeGSNotification(TAny* aObj)
{
if (aObj)
{
static_cast<CAknFepSharedDataInterface*>(aObj)->HandlePredictiveTextSettingGSChange();
return KErrNone;
}
else
{
return KErrArgument;
}
}
TInt CAknFepSharedDataInterface::JapanesePredictiveTextSettingChangeGSNotification(TAny* aObj)
{
if (aObj)
{
static_cast<CAknFepSharedDataInterface*>(aObj)->HandleJapanesePredictiveTextSettingGSChange();
return KErrNone;
}
else
{
return KErrArgument;
}
}
TInt CAknFepSharedDataInterface::QwertyModeChangeNotification(TAny* aObj)
{
if (aObj)
{
static_cast<CAknFepSharedDataInterface*>(aObj)->HandleQwertyModeChangeNotification();
return KErrNone;
}
else
{
return KErrArgument;
}
}
void CAknFepSharedDataInterface::HandlePredictiveTextSettingGSChange()
{
TInt value = 0;
#ifdef RD_INTELLIGENT_TEXT_INPUT
if (iAknFepRepository)
{
iAknFepRepository->Get(KAknFepPredTxtFlagExtension, value);
}
TPtiKeyboardType layout = (TPtiKeyboardType)KeyboardLayout();
switch(layout)
{
case EPtiKeyboardNone:
break;
case EPtiKeyboard12Key:
value &= EKeyboardStyle12Key;
break;
case EPtiKeyboardHalfQwerty:
value &= EKeyboardStyleHalfQwerty;
break;
case EPtiKeyboardQwerty4x12:
case EPtiKeyboardQwerty4x10:
case EPtiKeyboardQwerty3x11:
case EPtiKeyboardCustomQwerty:
value &= EKeyboardStyleQwerty;
break;
default:
break;
}
if (value > 0)
{
value = 1;
}
#else
if (iAknFepRepository)
{
iAknFepRepository->Get(KAknFepPredTxtFlag, value);
}
#endif
iFepManager->SetWesternPredictive(value);
}
void CAknFepSharedDataInterface::HandleJapanesePredictiveTextSettingGSChange()
{
TInt value = 0;
if (iAknFepRepository)
{
iAknFepRepository->Get(KAknFepJapanesePredTxtFlag, value);
}
iFepManager->SetJapanesePredictive(value);
}
void CAknFepSharedDataInterface::HandleQwertyModeChangeNotification()
{
TInt value = 0;
iQwertyModeStatusProperty.Get(value);
iFepManager->SetQwertyMode(value);
}
TInt CAknFepSharedDataInterface::NumberModeChangesGSNotification()
{
iFepManager->NumberModeChangeGSNotification();
return KErrNone;
}
#ifdef RD_INTELLIGENT_TEXT_INPUT
//
//Intensionally not called methods
// JapanesePredictiveTextSettingChangeGSNotification()
// MultiTapTimerChangeGSNotification()
// JapaneseQwertyFlagsChangeGSNotification()
// PredictiveTextAutoCompleteSettingChangeGSNotification() - Autocompletion feature
//
TInt CAknFepSharedDataInterface::HandleGenericRepositoryChange(TAny* aPtr)
{
CAknFepSharedDataInterface *self = STATIC_CAST(CAknFepSharedDataInterface*, aPtr);
TInt error = KErrNone;
if(self->iAknFepRepositoryWatcher->ChangedKey() == KAknFepChineseInputMode)
{
error = InputModeChangeGSNotification(aPtr);
}
if(self->iAknFepRepositoryWatcher->ChangedKey() == KAknFepInputTxtLang)
{
error = InputTextLangGSNotification(aPtr);
}
if(self->iAknFepRepositoryWatcher->ChangedKey() == KAknFepPredTxtFlag)
{
error = PredictiveTextSettingChangeGSNotification(aPtr);
}
if(self->iAknFepRepositoryWatcher->ChangedKey() == KAknFepAutoCompleteFlag)
{
error = PredictiveTextAutoCompleteSettingChangeGSNotification(aPtr);
}
if(self->iAknFepRepositoryWatcher->ChangedKey() == KAknFepTypingCorrectionLevel)
{
error = PredictiveTextTypingCorrectionLevelChangeNotification(aPtr);
}
if(self->iAknFepRepositoryWatcher->ChangedKey() == KAknFepNumberCandidateFlag)
{
error = PredictiveTextNumberCandidateSettingChangeNotification(aPtr);
}
if(self->iAknFepRepositoryWatcher->ChangedKey() == KAknFepPrimaryCandidateFlag)
{
error = PredictiveTextPrimaryCandidateChangeNotification(aPtr);
}
return error;
}
TPtiKeyboardType CAknFepSharedDataInterface::ActiveKeyboardType() const
{
TInt keyboardType = EPtiKeyboardNone;
#ifdef RD_SCALABLE_UI_V2
// Get physical keyboard type
RProperty::Get(KCRUidAvkon, KAknKeyBoardLayout, keyboardType );
// When active keyboard is virtual keyboard,
// need to get the active virtual keyboard type
// and set keyboardType again.
// When the default physical keyboard is 0,
// it means that there is no physical keyboard,
// also need to get the active virtual keyboard type.
TInt isVirtualInputActive = 0;
RProperty::Get( KPSUidAknFep, KAknFepTouchInputActive,
isVirtualInputActive );
if ( isVirtualInputActive > 0 || keyboardType == 0 )
{
// Active keyboard is virtual keyboard
RProperty::Get( KPSUidAknFep, KAknFepVirtualKeyboardType,
keyboardType );
}
#else
// Get physical keyboard type
RProperty::Get(KCRUidAvkon, KAknKeyBoardLayout, keyboardType );
#endif
if ( keyboardType <= 0 || keyboardType >= EPtiKeyboardMaxLayout )
{
keyboardType = EPtiKeyboardNone;
}
return (TPtiKeyboardType)keyboardType;
}
#endif // RD_INTELLIGENT_TEXT_INPUT
TInt CAknFepSharedDataInterface::HandleRepositoryCallBack(TAny* aPtr)
{
CAknFepSharedDataInterface *self = STATIC_CAST(CAknFepSharedDataInterface*, aPtr);
#ifdef RD_INTELLIGENT_TEXT_INPUT
if( self->iAknFepRepositoryWatcher &&
self->iAknFepRepositoryWatcher->IsGenericCenrepChange())
{
return HandleGenericRepositoryChange(aPtr);
}
else
#endif
if (self->iAknFepRepositoryWatcher)
{
if (self->iAknFepRepositoryWatcher->ChangedKey() == KAknFepHashKeySelection)
{
return HashKeySelectionNotification(aPtr);
}
if (self->iAknFepRepositoryWatcher->ChangedKey() == KAknFepChineseInputMode)
{
return InputModeChangeGSNotification(aPtr);
}
else if (self->iAknFepRepositoryWatcher->ChangedKey() == KAknFepInputTxtLang)
{
return InputTextLangGSNotification(aPtr);
}
#ifdef RD_INTELLIGENT_TEXT_INPUT
#ifdef FF_DUAL_LANGUAGE_SUPPORT
else if (self->iAknFepRepositoryWatcher->ChangedKey() == KAknFepInputTxtLangSecondary)
{
return InputTextLangGSNotification(aPtr);
}
#endif //FF_DUAL_LANGUAGE_SUPPORT
#endif
else if (self->iAknFepRepositoryWatcher->ChangedKey() == KAknFepPredTxtFlag)
{
return PredictiveTextSettingChangeGSNotification(aPtr);
}
else if (self->iAknFepRepositoryWatcher->ChangedKey() == KAknFepJapanesePredTxtFlag)
{
return JapanesePredictiveTextSettingChangeGSNotification(aPtr);
}
else if (self->iAknFepRepositoryWatcher->ChangedKey() == KAknFepMultiTapTimer)
{
return MultiTapTimerChangeGSNotification(aPtr);
}
else if (self->iAknFepRepositoryWatcher->ChangedKey() == KAknFepJapaneseSpecialCharFlag)
{
return JapaneseQwertyFlagsChangeGSNotification(aPtr);
}
#ifndef RD_INTELLIGENT_TEXT_INPUT
else if (self->iAknFepRepositoryWatcher->ChangedKey() == KAknFepAutoCompleteFlag)
{
return PredictiveTextAutoCompleteSettingChangeGSNotification(aPtr);
}
#endif //RD_INTELLIGENT_TEXT_INPUT
#ifdef RD_INTELLIGENT_TEXT_INPUT
else if (self->iAknFepRepositoryWatcher->ChangedKey() == KAknFepAutoCompleteFlag)
{
return PredictiveTextAutoCompleteSettingChangeGSNotification(aPtr);
}
else if (self->iAknFepRepositoryWatcher->ChangedKey() == KAknFepTypingCorrectionLevel)
{
return PredictiveTextTypingCorrectionLevelChangeNotification(aPtr);
}
else if (self->iAknFepRepositoryWatcher->ChangedKey() == KAknFepNumberCandidateFlag)
{
return PredictiveTextNumberCandidateSettingChangeNotification(aPtr);
}
else if (self->iAknFepRepositoryWatcher->ChangedKey() == KAknFepPrimaryCandidateFlag)
{
return PredictiveTextPrimaryCandidateChangeNotification(aPtr);
}
else if (self->iAknFepRepositoryWatcher->ChangedKey() == KAknFepPredTxtFlagExtension)
{
return PredictiveTextSettingChangeGSNotification(aPtr);
}
#endif
}
return KErrNone;
}
TInt CAknFepSharedDataInterface::HandleLocaleRepositoryCallBack(TAny* aPtr)
{
CAknFepSharedDataInterface *self = STATIC_CAST(CAknFepSharedDataInterface*, aPtr);
if(self->iAknFepLocaleRepositoryWatcher)
{
if (self->iAknFepLocaleRepositoryWatcher->ChangedKey() == KSettingsDefaultNumberMode
|| self->iAknFepLocaleRepositoryWatcher->ChangedKey() == KSettingsIndicDefaultNumberMode)
{
return self->NumberModeChangesGSNotification();
}
}
return KErrNone;
}
CAknFepSharedDataInterface::CSubscriber::CSubscriber(TCallBack aCallBack, RProperty& aProperty)
:
CActive(EPriorityNormal), iCallBack(aCallBack), iProperty(aProperty)
{
CActiveScheduler::Add(this);
}
CAknFepSharedDataInterface::CSubscriber::~CSubscriber()
{
Cancel();
}
void CAknFepSharedDataInterface::CSubscriber::SubscribeL()
{
if (!IsActive())
{
iProperty.Subscribe(iStatus);
SetActive();
}
}
void CAknFepSharedDataInterface::CSubscriber::StopSubscribe()
{
Cancel();
}
void CAknFepSharedDataInterface::CSubscriber::RunL()
{
if (iStatus.Int() == KErrNone)
{
iCallBack.CallBack();
SubscribeL();
}
}
void CAknFepSharedDataInterface::CSubscriber::DoCancel()
{
iProperty.Cancel();
}
TInt CAknFepSharedDataInterface::EditSubmenuInUse() const
{
TInt value = 0;
if (iAknFepRepository)
{
iAknFepRepository->Get(KAknFepHashKeySelection, value);
}
return value;
}
TInt CAknFepSharedDataInterface::HashKeySelectionInUse()
{
// This is never used in qwerty modes.
if (QwertyInputMode())
{
return 0;
}
TInt value = 0;
if (iAknFepRepository)
{
iAknFepRepository->Get(KAknFepHashKeySelection, value);
}
return iHashKeySelectionInUse;
}
CAknFepRepositoryWatcher* CAknFepRepositoryWatcher::NewL(
const TUid aUid,
const TUint32 aKey,
CCenRepNotifyHandler::TCenRepKeyType aKeyType,
TCallBack aCallBack,
CRepository* aRepository)
{
CAknFepRepositoryWatcher* self = new(ELeave) CAknFepRepositoryWatcher(aUid, aKey, aCallBack,
aRepository);
CleanupStack::PushL(self);
self->ConstructL(aKeyType);
CleanupStack::Pop(self);
return self;
}
CAknFepRepositoryWatcher* CAknFepRepositoryWatcher::NewL(
const TUid aUid,
TCallBack aCallBack,
CRepository* aRepository)
{
CAknFepRepositoryWatcher* self = new(ELeave) CAknFepRepositoryWatcher(aUid,
NCentralRepositoryConstants::KInvalidNotificationId,
aCallBack, aRepository);
CleanupStack::PushL(self);
self->ConstructL();
CleanupStack::Pop(self);
return self;
}
CAknFepRepositoryWatcher::~CAknFepRepositoryWatcher()
{
if( iNotifyHandler )
{
iNotifyHandler->StopListening();
delete iNotifyHandler;
iNotifyHandler = NULL;
}
}
CAknFepRepositoryWatcher::CAknFepRepositoryWatcher(
const TUid aUid,
const TUint32 aKey,
TCallBack aCallBack,
CRepository* aRepository)
:
iUid(aUid), iKey(aKey), iCallBack(aCallBack), iRepository(aRepository)
#ifdef RD_INTELLIGENT_TEXT_INPUT
, iIsGeneric (EFalse)
#endif
{
}
void CAknFepRepositoryWatcher::ConstructL(CCenRepNotifyHandler::TCenRepKeyType aKeyType)
{
iNotifyHandler = CCenRepNotifyHandler::NewL(*this, *iRepository, aKeyType, iKey);
iNotifyHandler->StartListeningL();
}
void CAknFepRepositoryWatcher::ConstructL()
{
iNotifyHandler = CCenRepNotifyHandler::NewL(*this, *iRepository);
iNotifyHandler->StartListeningL();
}
TUint32 CAknFepRepositoryWatcher::ChangedKey()
{
return iChangedKey;
}
void CAknFepRepositoryWatcher::HandleNotifyInt(TUint32 aKey, TInt aNewValue)
{
#ifdef _DEBUG
RDebug::Print(_L("AknFep: HandleNotifyInt aKey=%d, aNewValue=%d"), aKey, aNewValue);
#endif
iChangedKey = aKey;
#ifdef RD_INTELLIGENT_TEXT_INPUT
iIsGeneric = EFalse;
#endif
iCallBack.CallBack();
iChangedKey = NCentralRepositoryConstants::KInvalidNotificationId;
}
void CAknFepRepositoryWatcher::HandleNotifyError(TUint32 /*aKey*/, TInt /*aError*/, CCenRepNotifyHandler* /*aHandler*/)
{
}
/*
#ifdef RD_INTELLIGENT_TEXT_INPUT
void CAknFepRepositoryWatcher::HandleNotifyGeneric(TUint32 aId)
{
#ifdef _DEBUG
RDebug::Print(_L("AknFep: HandleNotifyGeneric aId=%d"), aId);
#endif
iChangedKey = aId;
iIsGeneric = ETrue;
iCallBack.CallBack();
iChangedKey = NCentralRepositoryConstants::KInvalidNotificationId;
}
#else*/
void CAknFepRepositoryWatcher::HandleNotifyGeneric(TUint32 aId)
{
#ifdef _DEBUG
RDebug::Print(_L("AknFep: HandleNotifyGeneric aId=%d"), aId);
#endif
iChangedKey = aId;
iCallBack.CallBack();
iChangedKey = NCentralRepositoryConstants::KInvalidNotificationId;
}
//#endif
/**
* Multitap timer value.
* Replaces the constant KMultiTapTimeoutMS in Japanese variant.
*
* @since 3.0
* @return Value of KAknFepMultiTapTimer setting.
*/
TInt CAknFepSharedDataInterface::MultiTapTimer() const
{
TInt value = 1000000;
if (iAknFepRepository)
{
iAknFepRepository->Get(KAknFepMultiTapTimer, value);
}
return value;
}
/**
* Change notification for Multitap timer.
*
* @since 3.0
* @return return KErrNone if aObj isn't NULL
* return KErrArgument if aObj is NULL
*/
TInt CAknFepSharedDataInterface::MultiTapTimerChangeGSNotification(TAny* aObj)
{
if (aObj)
{
static_cast<CAknFepSharedDataInterface*>(aObj)->HandleMultiTapTimerChangeGSNotification();
return KErrNone;
}
else
{
return KErrArgument;
}
}
/**
* Handle change notification for Multitap timer.
*
* @since 3.0
*/
void CAknFepSharedDataInterface::HandleMultiTapTimerChangeGSNotification()
{
TInt value = MultiTapTimer();
iFepManager->SetMultiTapTimer(value);
}
/**
* Japanese Qwerty Flags value.
* Replaces the constant KAknFepJapaneseSpecialCharFlag in Japanese variant.
*
* @since 3.0
* @return Value of KAknFepJapaneseSpecialCharFlag setting.
*/
TInt CAknFepSharedDataInterface::JapaneseQwertyFlags() const
{
TInt value = 0x000F;
if (iAknFepRepository)
{
iAknFepRepository->Get(KAknFepJapaneseSpecialCharFlag, value);
}
return value;
}
/**
* Change notification for Japanese Qwerty Flags.
*
* @since 3.0
* @return return KErrNone if aObj isn't NULL
* return KErrArgument if aObj is NULL
*/
TInt CAknFepSharedDataInterface::JapaneseQwertyFlagsChangeGSNotification(TAny* aObj)
{
if (aObj)
{
static_cast<CAknFepSharedDataInterface*>(aObj)->HandleJapaneseQwertyFlagsChangeGSNotification();
return KErrNone;
}
else
{
return KErrArgument;
}
}
/**
* Handle change notification for Japanese Qwerty Flags.
*
* @since 3.0
*/
void CAknFepSharedDataInterface::HandleJapaneseQwertyFlagsChangeGSNotification()
{
TInt value = JapaneseQwertyFlags();
iFepManager->SetJapaneseQwertyFlags(value);
}
/**
* Returns a value of current clear direction.
*
* @since 3.2
* @return Value of KAknFepClearDirection setting.
*/
TInt CAknFepSharedDataInterface::ClearDirection() const
{
TInt value = EClearDirectionLeft;
if (iAknFepRepository)
{
iAknFepRepository->Get(KAknFepClearDirection, value);
}
return value;
}
/**
* Set a value of current clear direction.
*
* @since 3.2
* @param aValue new value set to Clear Direction shared data item which
* represents the direction currently being used
*/
void CAknFepSharedDataInterface::SetClearDirection(TInt aValue)
{
if (iAknFepRepository)
{
iAknFepRepository->Set(KAknFepClearDirection, aValue);
}
}
#ifdef RD_INTELLIGENT_TEXT_INPUT
TInt CAknFepSharedDataInterface::HandleKeyboardLayoutChangeNotification(TAny* aObj)
{
if (aObj)
{
static_cast<CAknFepSharedDataInterface*>(aObj)->HandleKeyboardLayoutChange();
return KErrNone;
}
else
{
return KErrArgument;
}
}
#ifdef RD_SCALABLE_UI_V2
TInt CAknFepSharedDataInterface::HandleVirtualKeyboardLayoutChangeNotification(TAny* aObj)
{
if (aObj)
{
static_cast<CAknFepSharedDataInterface*>(aObj)->HandleVirtualKeyboardLayoutChange();
return KErrNone;
}
else
{
return KErrArgument;
}
}
#endif // RD_SCALABLE_UI_V2
#endif
void CAknFepSharedDataInterface::SetPredictiveTextAutoCompleteOn()
{
if (iAknFepRepository)
{
#ifdef RD_INTELLIGENT_TEXT_INPUT
//Set autocomplete flag only for the current keyboard layout type. Otherwise,
//by simply setting to "1", we los information on autocompletion settings
//of other keyboard types.
TPtiKeyboardType currentKeyboardLayoutlayout = (TPtiKeyboardType)KeyboardLayout();
TInt autocompletionSetting = 0;
iAknFepRepository->Get(KAknFepAutoCompleteFlag, autocompletionSetting);
switch(currentKeyboardLayoutlayout)
{
case EPtiKeyboardNone:
break;
case EPtiKeyboard12Key:
autocompletionSetting |= EKeyboardStyle12Key;
break;
case EPtiKeyboardQwerty4x12:
case EPtiKeyboardQwerty4x10:
case EPtiKeyboardQwerty3x11:
case EPtiKeyboardHalfQwerty:
case EPtiKeyboardCustomQwerty:
autocompletionSetting |= EKeyboardStyleQwerty;
break;
default:
break;
}
iAknFepRepository->Set(KAknFepAutoCompleteFlag, autocompletionSetting);
#else
iAknFepRepository->Set(KAknFepAutoCompleteFlag, 1);
#endif
}
}
void CAknFepSharedDataInterface::ResetPredictiveTextAutoCompleteOn()
{
if (iAknFepRepository)
{
#ifdef RD_INTELLIGENT_TEXT_INPUT
//Reset autocomplete flag only for the current keyboard layout type. Otherwise,
//by simply setting to "0", we lose information on autocompletion settings
//of other keyboard types.
TPtiKeyboardType currentKeyboardLayoutlayout = (TPtiKeyboardType)KeyboardLayout();
TInt autocompletionSetting = 0;
iAknFepRepository->Get(KAknFepAutoCompleteFlag, autocompletionSetting);
switch(currentKeyboardLayoutlayout)
{
case EPtiKeyboardNone:
break;
case EPtiKeyboard12Key:
autocompletionSetting &= ~EKeyboardStyle12Key;
break;
case EPtiKeyboardQwerty4x12:
case EPtiKeyboardQwerty4x10:
case EPtiKeyboardQwerty3x11:
case EPtiKeyboardHalfQwerty:
case EPtiKeyboardCustomQwerty:
autocompletionSetting &= ~EKeyboardStyleQwerty;
break;
default:
break;
}
iAknFepRepository->Set(KAknFepAutoCompleteFlag, autocompletionSetting);
#else
iAknFepRepository->Set(KAknFepAutoCompleteFlag, 0);
#endif
}
}
#ifndef RD_INTELLIGENT_TEXT_INPUT
void CAknFepSharedDataInterface::HandlePredictiveTextAutoCompleteSettingGSChange()
{
TInt value = 0;
if (iAknFepRepository)
{
iAknFepRepository->Get(KAknFepAutoCompleteFlag, value);
}
iFepManager->SetAutoCompletionState(value);
}
TInt CAknFepSharedDataInterface::PredictiveTextAutoCompleteSettingChangeGSNotification(TAny* aObj)
{
if (aObj)
{
static_cast<CAknFepSharedDataInterface*>(aObj)->HandlePredictiveTextAutoCompleteSettingGSChange();
return KErrNone;
}
else
{
return KErrArgument;
}
}
#endif //RD_INTELLIGENT_TEXT_INPUT
#ifdef RD_INTELLIGENT_TEXT_INPUT
void CAknFepSharedDataInterface::SetFnKeyState(TInt aState)
{
RProperty::Set(KPSUidAknFep,KAknFepFnKeyState, aState);
}
TInt CAknFepSharedDataInterface::GetFnKeyState()
{
TInt state = 0;
RProperty::Get(KPSUidAknFep,KAknFepFnKeyState, state);
return state;
}
void CAknFepSharedDataInterface::HandleKeyboardLayoutChange()
{
TInt value = 0;
TPtiKeyboardType keyboardType;
iKeyboardLayoutStatusProperty.Get(value);
keyboardType = (TPtiKeyboardType)value;
iFepManager->SetKeyboardLayout(keyboardType);
iFepManager->SetFnKeyMappingState();
#ifdef __ITI_VIRTUAL_TOUCH_FIRST_GENERATION_SUPPORT__
iFepManager->StopDisplayingMenuBar();
#endif //__ITI_VIRTUAL_TOUCH_FIRST_GENERATION_SUPPORT__
}
#ifdef RD_SCALABLE_UI_V2
// ---------------------------------------------------------------------------
// Handles the change to virtual keyboard layout.
//
// ---------------------------------------------------------------------------
//
void CAknFepSharedDataInterface::HandleVirtualKeyboardLayoutChange()
{
TInt value = 0;
TPtiKeyboardType keyboardType;
iVirtualKeyboardLayoutStatusProperty.Get(value);
keyboardType = (TPtiKeyboardType)value;
iFepManager->SetKeyboardLayout(keyboardType);
iFepManager->SetFnKeyMappingState();
}
#endif // RD_SCALABLE_UI_V2
TInt CAknFepSharedDataInterface::PredictiveTextAutoCompleteOn()
{
TInt value = 0;
if (iAknFepRepository)
{
TPtiKeyboardType layout = (TPtiKeyboardType)KeyboardLayout();
TInt temp = 0;
iAknFepRepository->Get(KAknFepAutoCompleteFlag, temp);
switch(layout)
{
case EPtiKeyboardNone:
break;
case EPtiKeyboard12Key:
temp &= EKeyboardStyle12Key;
break;
case EPtiKeyboardHalfQwerty:
temp &= EKeyboardStyleHalfQwerty;
break;
case EPtiKeyboardQwerty4x12:
case EPtiKeyboardQwerty4x10:
case EPtiKeyboardQwerty3x11:
case EPtiKeyboardCustomQwerty:
temp &= EKeyboardStyleQwerty;
break;
default:
break;
}
value = ( temp ? 1 : 0);
}
return value;
}
void CAknFepSharedDataInterface::HandlePredictiveTextAutoCompleteSettingGSChange()
{
TInt value = 0;
if (iAknFepRepository)
{
iAknFepRepository->Get(KAknFepAutoCompleteFlag, value);
}
TPtiKeyboardType layout = (TPtiKeyboardType)KeyboardLayout();
switch(layout)
{
case EPtiKeyboardNone:
break;
case EPtiKeyboard12Key:
value &= EKeyboardStyle12Key;
break;
case EPtiKeyboardHalfQwerty:
value &= EKeyboardStyleHalfQwerty;
break;
case EPtiKeyboardQwerty4x12:
case EPtiKeyboardQwerty4x10:
case EPtiKeyboardQwerty3x11:
case EPtiKeyboardCustomQwerty:
value &= EKeyboardStyleQwerty;
break;
default:
break;
}
if (value > 0)
{
value = 1;
}
iFepManager->SetAutoCompletionState(value);
}
TInt CAknFepSharedDataInterface::PredictiveTextAutoCompleteSettingChangeGSNotification(TAny* aObj)
{
if (aObj)
{
static_cast<CAknFepSharedDataInterface*>(aObj)->HandlePredictiveTextAutoCompleteSettingGSChange();
return KErrNone;
}
else
{
return KErrArgument;
}
}
/**
* Queries the value of PredictiveText Typing Correction Level from shared data
*
* @return Typing Correction Level
*/
TInt CAknFepSharedDataInterface::PredictiveTextTypingCorrectionLevel()
{
TInt value = 0;
if (iAknFepRepository)
{
iAknFepRepository->Get(KAknFepTypingCorrectionLevel, value);
}
return value;
}
/**
* Sets the value of PredictiveText Typing Correction Level state to aCorrectionLevel in shared data
*/
void CAknFepSharedDataInterface::SetPredictiveTextTypingCorrectionLevel(TInt aCorrectionLevel)
{
if (iAknFepRepository)
{
iAknFepRepository->Set(KAknFepTypingCorrectionLevel, aCorrectionLevel);
}
}
void CAknFepSharedDataInterface::HandlePredictiveTextTypingCorrectionLevelChange()
{
TInt value = 0;
if (iAknFepRepository)
{
iAknFepRepository->Get(KAknFepTypingCorrectionLevel, value);
}
iFepManager->SetTypingCorrectionLevel(value);
}
/**
* Handles a change in predictive text Typing Correction Level setting.
*/
TInt CAknFepSharedDataInterface::PredictiveTextTypingCorrectionLevelChangeNotification(TAny* aObj)
{
if (aObj)
{
static_cast<CAknFepSharedDataInterface*>(aObj)->HandlePredictiveTextTypingCorrectionLevelChange();
return KErrNone;
}
else
{
return KErrArgument;
}
}
/**
* Queries the value of PredictiveText Number Candidate Shown state to be On from shared data
*
* @return 1 for shown or 0 for not shown
*/
TInt CAknFepSharedDataInterface::PredictiveTextNumberCandidateShown()
{
TInt value = 0;
if (iAknFepRepository)
{
iAknFepRepository->Get(KAknFepNumberCandidateFlag, value);
}
return value;
}
/**
* Sets the value of PredictiveText Number Candidate Shown state to 1 in shared data - this
* is used to represent predictive text Number Candidate Shown being shown.
*/
void CAknFepSharedDataInterface::SetPredictiveTextNumberCandidateShown()
{
if (iAknFepRepository)
{
iAknFepRepository->Set(KAknFepNumberCandidateFlag, 1);
}
}
/**
* Sets the value of PredictiveText Number Candidate Shown state to 0 in shared data - this
* is used to represent predictive text Number Candidate Shown being not shown.
*/
void CAknFepSharedDataInterface::ResetPredictiveTextNumberCandidateShown()
{
if (iAknFepRepository)
{
iAknFepRepository->Set(KAknFepNumberCandidateFlag, 0);
}
}
void CAknFepSharedDataInterface::HandlePredictiveTextNumberCandidateSettingChange()
{
TInt value = 0;
if (iAknFepRepository)
{
iAknFepRepository->Get(KAknFepNumberCandidateFlag, value);
}
iFepManager->SetNumberCandidateState(value);
}
/**
* Handles a change in predictive text Number Candidate Shown setting.
*/
TInt CAknFepSharedDataInterface::PredictiveTextNumberCandidateSettingChangeNotification(TAny* aObj)
{
if (aObj)
{
static_cast<CAknFepSharedDataInterface*>(aObj)->HandlePredictiveTextNumberCandidateSettingChange();
return KErrNone;
}
else
{
return KErrArgument;
}
}
/**
* Queries the value of PredictiveText Primary candidate setting from shared data
*
* @return Primary candidate setting(0 for Suggested or 1 for Exact)
*/
TInt CAknFepSharedDataInterface::PredictiveTextPrimaryCandidate()
{
TInt value = 0;
if (iAknFepRepository)
{
iAknFepRepository->Get(KAknFepPrimaryCandidateFlag, value);
}
return value;
}
/**
* Sets the value of PredictiveText Primary candidate setting state to aPrimaryCandidate in shared data
*/
void CAknFepSharedDataInterface::SetPredictiveTextPrimaryCandidate(TInt aPrimaryCandidate)
{
if (iAknFepRepository)
{
iAknFepRepository->Set(KAknFepPrimaryCandidateFlag, aPrimaryCandidate);
}
}
/**
* Handles a change in predictive text Primary candidate setting.
*/
void CAknFepSharedDataInterface::HandlePredictiveTextPrimaryCandidateChange()
{
TInt value = 0;
if (iAknFepRepository)
{
iAknFepRepository->Get(KAknFepPrimaryCandidateFlag, value);
}
iFepManager->SetPrimaryCandidate(value);
}
/**
* Handles a change in predictive text Typing Correction Level setting.
*/
TInt CAknFepSharedDataInterface::PredictiveTextPrimaryCandidateChangeNotification(TAny* aObj)
{
if (aObj)
{
static_cast<CAknFepSharedDataInterface*>(aObj)->HandlePredictiveTextPrimaryCandidateChange();
return KErrNone;
}
else
{
return KErrArgument;
}
}
#else // RD_INTELLIGENT_TEXT_INPUT
TInt CAknFepSharedDataInterface::PredictiveTextAutoCompleteOn()
{
TInt value = 0;
if (iAknFepRepository)
{
iAknFepRepository->Get(KAknFepAutoCompleteFlag, value);
}
return value;
}
#endif
/**
* Returns a value of HWR conversion on/off.
*
* @since 3.2
* @return Value of KAknFepJapaneseHwrConversion setting.
*/
TInt CAknFepSharedDataInterface::JapaneseHwrConversion() const
{
TInt value = 0;
if (iAknFepRepository)
{
iAknFepRepository->Get(KAknFepJapaneseSpecialCharFlag, value);
}
return (value & KJapHwrConversion)?
EJapaneseConversionOn : EJapaneseConversionOff;
}
/**
* Set a value of HWR conversion on/off.
*
* @since 3.2
* @param aValue new value set to HWR conversion on/off shared data item
*/
void CAknFepSharedDataInterface::SetJapaneseHwrConversion(TInt aValue)
{
if (iAknFepRepository)
{
TInt value;
iAknFepRepository->Get(KAknFepJapaneseSpecialCharFlag, value);
if (aValue == EJapaneseConversionOn)
{
value |= KJapHwrConversion;
}
else
{
value &= ~(KJapHwrConversion);
}
iAknFepRepository->Set(KAknFepJapaneseSpecialCharFlag, value);
}
}
TInt CAknFepSharedDataInterface::FepShowFsqPreviewStatus()
{
TInt value = 0;
if (iAknFepRepository)
{
iAknFepRepository->Get(KAknFepShowFsqPreview, value);
}
return value;
}
void CAknFepSharedDataInterface::SetFepShowFsqPreviewStatus(TInt aValue)
{
if (iAknFepRepository)
{
iAknFepRepository->Set(KAknFepShowFsqPreview, aValue);
}
}
TInt CAknFepSharedDataInterface::FepShowVkbPreviewStatus()
{
TInt value = 0;
if (iAknFepRepository)
{
iAknFepRepository->Get(KAknFepShowVkbPreview, value);
}
return value;
}
void CAknFepSharedDataInterface::SetFepShowVkbPreviewStatus(TInt aValue)
{
if (iAknFepRepository)
{
iAknFepRepository->Set(KAknFepShowVkbPreview, aValue);
}
}
TInt CAknFepSharedDataInterface::FepLastUseVkbModeForLandscape()
{
TInt value = 4;
if (iAknFepRepository)
{
iAknFepRepository->Get(KAknFepLastUseVkbMode, value);
}
return value;
}
void CAknFepSharedDataInterface::SetFepLastUseVkbModeForLandscape(TInt aValue)
{
if (iAknFepRepository)
{
iAknFepRepository->Set(KAknFepLastUseVkbMode, aValue);
}
}
TBool CAknFepSharedDataInterface::AutoRotateEnabled()
{
TInt sensorState( 0 );
if (iSensorRepository)
{
iSensorRepository->Get( KSenSettingsSensorsOn, sensorState );
}
if ( sensorState )
{
TInt turnCtrl = 0;
iSensorRepository->Get( KSenSettingsTurnCtrl, turnCtrl );
turnCtrl = turnCtrl >> 2;
if ( turnCtrl )
{
return ETrue;
}
}
return EFalse;
}
TBool CAknFepSharedDataInterface::ThemeEffectsEnabled()
{
TInt effectsValue = KErrNone;
TInt error = iThemeEffectsRepository->Get( KThemesTransitionEffects, effectsValue );
if ( error != KErrNone || effectsValue != 0 )//zero means on
{
effectsValue = KErrNotFound;
}
return effectsValue == KErrNone ? ETrue:EFalse;
}
#ifdef RD_INTELLIGENT_TEXT_INPUT
#ifdef __ITI_LONGPRESS_NUM_SHIFT_COPYPASTE__
/**
* Queries if numbers (and other characters found behind Fn) can be entered with long key press on QWERTY.
*/
TBool CAknFepSharedDataInterface::LongPressNumberEntryOnQwerty() const
{
TInt value = 0;
if (iAknFepRepository)
{
iAknFepRepository->Get(KAknFepLongPressNumberEntryOnQwerty, value);
}
return value;
}
/**
* Queries if copy-pasting with shift+softkeys is available also on QWERTY.
*/
TBool CAknFepSharedDataInterface::ShiftCopyPastingOnQwerty() const
{
TInt value = 0;
if (iAknFepRepository)
{
iAknFepRepository->Get(KAknFepShiftCopyPasteOnQwerty, value);
}
return value;
}
#endif // __ITI_LONGPRESS_NUM_SHIFT_COPYPASTE__
#endif // RD_INTELLIGENT_TEXT_INPUT
#ifdef RD_SCALABLE_UI_V2
// ---------------------------------------------------------------------------
// Get a value of current default on screen vkb.
// It depends on input lanage is PRC/HW/TW Chinese.
// ---------------------------------------------------------------------------
//
TInt CAknFepSharedDataInterface::DefaultOnScreenVKB()
{
TInt value = 0;
switch( PenInputLanguage() )
{
case ELangPrcChinese:
{
iGsPenSettings->Get( KSettingsDefaultVkbPrc, value );
}
break;
case ELangHongKongChinese:
{
iGsPenSettings->Get( KSettingsDefaultVkbHk, value );
}
break;
case ELangTaiwanChinese:
{
iGsPenSettings->Get( KSettingsDefaultVkbTw, value );
}
break;
default:
break;
}
return value;
};
/**
* Returns a value of default arabic finger hwr orientation.
*
* @since 5.2
* @return Value of default arabic finger hwr orientation.
*/
TInt CAknFepSharedDataInterface::DefaultArabicFingerHwrOrientation() const
{
TInt value = 0;
if (iAknFepRepository)
{
iAknFepRepository->Get(KAknFepDefaultArabicFingerHwrOrientation, value);
}
return value;
}
/**
* Set a value of default arabic finger hwr orientation.
*
* @since 5.2
* @param aValue new value set to default arabic finger hwr orientation shared data item
*/
void CAknFepSharedDataInterface::SetDefaultArabicFingerHwrOrientation(TInt aValue)
{
if (iAknFepRepository)
{
iAknFepRepository->Set(KAknFepDefaultArabicFingerHwrOrientation, aValue);
}
}
/**
* Returns a value of default arabic finger hwr number mode.
*
* @since 5.2
* @return Value of default arabic finger hwr number mode.
*/
TInt CAknFepSharedDataInterface::DefaultArabicNumberMode() const
{
TInt value = 0;
if (iAknFepRepository)
{
iAknFepRepository->Get(KAknFepDefaultArabicNumberMode, value);
}
return value;
}
/**
* Set a value of default arabic finger hwr number mode.
*
* @since 5.2
* @param aValue new value set to default arabic finger hwr number mode shared data item
*/
void CAknFepSharedDataInterface::SetDefaultArabicNumberMode(TInt aValue)
{
if (iAknFepRepository)
{
iAknFepRepository->Set(KAknFepDefaultArabicNumberMode, aValue);
}
}
#endif
/**
* Get the last used plugin input mode for portrait orientation
*
* @since 5.2
* @return Value of KAknFepLastUsedPortraitInput setting.
*/
TPluginInputMode CAknFepSharedDataInterface::PluginPortraitInputMode() const
{
TInt cenRepValue( 0 );
if ( iAknFepRepository )
{
iAknFepRepository->Get( KAknFepLastUsedPortraitInput, cenRepValue );
}
TPluginInputMode lastUsedPortraitInputMode =
static_cast<TPluginInputMode>( cenRepValue );
// Check portrait FSQ and ITU-T feature are enabled.
TBool isPortraitFSQEnabled = FeatureManager::FeatureSupported(
KFeatureIdFfVirtualFullscrPortraitQwertyInput );
TBool isITUTEnabled = FeatureManager::FeatureSupported(
KFeatureIdVirtualItutInput );
// If both ITU-T and portrait FSQ features are enabled, use the saved
// portrait input mode.
if ( isITUTEnabled && isPortraitFSQEnabled )
{
// If the saved portrait input mode is not valid, use the default
// value, EPluginInputModeItut.
if ( ! ( lastUsedPortraitInputMode == EPluginInputModeItut ||
lastUsedPortraitInputMode == EPluginInputModePortraitFSQ ) )
{
lastUsedPortraitInputMode = EPluginInputModeItut;
}
}
// If only ITU-T feature is enabled, use the mode.
else if ( isITUTEnabled )
{
lastUsedPortraitInputMode = EPluginInputModeItut;
}
// If only portrait FSQ feature is enabled, use the mode.
else if ( isPortraitFSQEnabled )
{
lastUsedPortraitInputMode = EPluginInputModePortraitFSQ;
}
// If none of the features are enabled, EPluginInputModeNone is assigned
// for exception handling.
else
{
lastUsedPortraitInputMode = EPluginInputModeNone;
}
return lastUsedPortraitInputMode;
}
/**
* Replaces the last used plugin input mode for portrait orientation
*
* @since 5.2
* @return Replace value of KAknFepLastUsedPortraitInput setting.
*/
void CAknFepSharedDataInterface::SetPluginPortraitInputMode(
TPluginInputMode aLastUsedPortraitInputMode )
{
// Check validity of the input mode to be set. The input mode is not
// valid if,
// i) The input mode is not neither ITU-T nor portrait FSQ.
if ( !( aLastUsedPortraitInputMode == EPluginInputModeItut ||
aLastUsedPortraitInputMode == EPluginInputModePortraitFSQ ) ||
// ii) The input mode is ITU-T but the feature is disabled.
( aLastUsedPortraitInputMode == EPluginInputModeItut &&
!FeatureManager::FeatureSupported( KFeatureIdVirtualItutInput ) ) ||
// iii) The input mode is portrait FSQ but the feature is disabled.
( aLastUsedPortraitInputMode == EPluginInputModePortraitFSQ &&
!FeatureManager::FeatureSupported(
KFeatureIdFfVirtualFullscrPortraitQwertyInput ) ) )
{
__ASSERT_DEBUG( 0,
User::Panic( _L( "Wrong portrait input mode" ), __LINE__ ) );
// Return without saving the value if the portrait input is invalid.
return;
}
if ( iAknFepRepository )
{
TInt err = iAknFepRepository->Set( KAknFepLastUsedPortraitInput,
static_cast<TInt>( aLastUsedPortraitInputMode ) );
}
}
// End of File