textinput/peninputarc/gsplugin/gspeninputplugin/src/gspeninputmodel.cpp
branchRCL_3
changeset 20 ebd48d2de13c
parent 8 4eb1ae11334f
child 21 ecbabf52600f
equal deleted inserted replaced
19:ac7e4d1d9209 20:ebd48d2de13c
    46 const TInt KGSLanguageMask = 0x03FF;
    46 const TInt KGSLanguageMask = 0x03FF;
    47 const TInt KISOCodeLength = 2;
    47 const TInt KISOCodeLength = 2;
    48 const TUid KUidtruiApp = { 0x2000B104 };
    48 const TUid KUidtruiApp = { 0x2000B104 };
    49 const TUid KUidPenInputSettingApp = { 0x2001959B };
    49 const TUid KUidPenInputSettingApp = { 0x2001959B };
    50 
    50 
    51 const TInt KFepChineseInputModeLength = 10;
       
    52 
       
    53 _LIT(KLeftBracket, "(" );
    51 _LIT(KLeftBracket, "(" );
    54 _LIT(KRightBracket, ")" );
    52 _LIT(KRightBracket, ")" );
    55 
    53 
    56 // ======== MEMBER FUNCTIONS ========
    54 // ======== MEMBER FUNCTIONS ========
    57 
    55 
  1185         {
  1183         {
  1186         case ELangPrcChinese:
  1184         case ELangPrcChinese:
  1187         case ELangHongKongChinese:
  1185         case ELangHongKongChinese:
  1188         case ELangTaiwanChinese:
  1186         case ELangTaiwanChinese:
  1189             {
  1187             {
  1190             TBuf<KFepChineseInputModeLength> conversion;
  1188             iAknfepRepository->Set(KAknFepChineseInputMode, aInputMode);
  1191             conversion.Num(aInputMode, EHex);
       
  1192             iAknfepRepository->Set( KAknFepChineseInputMode, conversion );
       
  1193             }
  1189             }
  1194             break;
  1190             break;
  1195          default:
  1191          default:
  1196             break;
  1192             break;
  1197         }
  1193         }
  1202 // Get FEP default input mode when language changed
  1198 // Get FEP default input mode when language changed
  1203 // ---------------------------------------------------------
  1199 // ---------------------------------------------------------
  1204 //
  1200 //
  1205 TInt CGSPenInputModel::GetFepInputMode()
  1201 TInt CGSPenInputModel::GetFepInputMode()
  1206     {
  1202     {
  1207     TUint inputMode = 0;
  1203     TInt inputMode = 0;
  1208     switch(iInputLanguage)
  1204     switch(iInputLanguage)
  1209         {
  1205         {
  1210         case ELangPrcChinese:
  1206         case ELangPrcChinese:
  1211         case ELangHongKongChinese:
  1207         case ELangHongKongChinese:
  1212         case ELangTaiwanChinese:
  1208         case ELangTaiwanChinese:
  1213             {
  1209             {
  1214             _LIT(Kx, "x");
  1210             iAknfepRepository->Get(KAknFepChineseInputMode, inputMode);
  1215             // This conversion is needed because KAknFepChineseInputMode cenrep key original type was 16bit int.
       
  1216             // now type is changed to string, so that it can accommodate bigger values like EHangul 0x16000. 
       
  1217             TBuf<KFepChineseInputModeLength> conversion;
       
  1218             iAknfepRepository->Get( KAknFepChineseInputMode, conversion );
       
  1219            
       
  1220             TInt len = conversion.Find(Kx);
       
  1221             TLex lex;
       
  1222             
       
  1223             if(len)
       
  1224                 {
       
  1225                 TPtrC ptr = conversion.Mid(len +1);
       
  1226                 lex.Assign(ptr);
       
  1227                 }
       
  1228             else
       
  1229                 {
       
  1230                 lex.Assign(conversion);
       
  1231                 }
       
  1232             
       
  1233             lex.Val(inputMode, EHex);
       
  1234             }
  1211             }
  1235             break;
  1212             break;
  1236          default:
  1213          default:
  1237             break;
  1214             break;
  1238         }
  1215         }
  1266     TBool res = EFalse;    
  1243     TBool res = EFalse;    
  1267     switch( aItemId )
  1244     switch( aItemId )
  1268         {
  1245         {
  1269         case EGSInputpenIdHwrTraining:
  1246         case EGSInputpenIdHwrTraining:
  1270             {
  1247             {
  1271             iIsHwrTrainingAviliable = EFalse;              
  1248             iIsHwrTrainingAviliable = EFalse;
       
  1249             TInt supportMode = EPluginInputModeNone;
       
  1250             if(KErrNone == iConnectErr)
       
  1251                 {
       
  1252                 supportMode = iPenInputServer.SupportInputMode();
       
  1253                 }
       
  1254             TBool supportHWR = EFalse;
       
  1255             if(supportMode & EPluginInputModeHwr ||
       
  1256                supportMode & EPluginInputModeFSc ||
       
  1257                supportMode & EPluginInputModeFingerHwr)
       
  1258                 {
       
  1259                 supportHWR = ETrue;
       
  1260                 }
       
  1261               
  1272             CEikonEnv* env = CEikonEnv::Static();
  1262             CEikonEnv* env = CEikonEnv::Static();
  1273             TUid appUid = env->EikAppUi()
  1263             TUid appUid = env->EikAppUi()
  1274                           ->Application()->AppDllUid();
  1264                           ->Application()->AppDllUid();
  1275             if ( appUid == KUidPenInputSettingApp )
  1265             if ( appUid == KUidPenInputSettingApp )
  1276                 {
  1266                 {
  1283                 if ( parentUid == KUidtruiApp )
  1273                 if ( parentUid == KUidtruiApp )
  1284                    {
  1274                    {
  1285                     iIsHwrTrainingAviliable = EFalse;                    
  1275                     iIsHwrTrainingAviliable = EFalse;                    
  1286                     }
  1276                     }
  1287                 else
  1277                 else
  1288                     {
  1278                        {
  1289                     iIsHwrTrainingAviliable = IsTruiSupportedLanguage();
  1279                     iIsHwrTrainingAviliable = IsTruiSupportedLanguage();
  1290                     }
  1280                        }
  1291                 }                
  1281                    }                
  1292             else
  1282             else
  1293                 {
  1283                 {
  1294                 iIsHwrTrainingAviliable = IsTruiSupportedLanguage();
  1284                 iIsHwrTrainingAviliable = IsTruiSupportedLanguage();
  1295                 }
  1285                 }
  1296             res = ( !ChineseLanguage() && !JapaneseLanguage() 
  1286             res = ( !ChineseLanguage() && !JapaneseLanguage() && iIsHwrTrainingAviliable && supportHWR);
  1297             		&& iIsHwrTrainingAviliable 
       
  1298             		&& IsSupportHWR() );
       
  1299             }
  1287             }
  1300             break;
  1288             break;
  1301         case EGSInputpenIdInputLanguage:
  1289         case EGSInputpenIdInputLanguage:
  1302             {
  1290             {
  1303             res = ETrue;
  1291             res = ETrue;
  1315             }                        
  1303             }                        
  1316             break;
  1304             break;
  1317             
  1305             
  1318         case EGSInputpenIdGuidLine:
  1306         case EGSInputpenIdGuidLine:
  1319             {
  1307             {
  1320             res = ( !ChineseLanguage() && !JapaneseLanguage() && IsSupportHWR());
  1308             TInt supportMode = EPluginInputModeNone;
  1321             if(FeatureManager::FeatureSupported(KFeatureIdFfCapacitiveDisplay)&&
  1309             if(KErrNone == iConnectErr)
  1322                     iInputLanguage == ELangArabic)
  1310                 {
  1323                 {
  1311                 supportMode = iPenInputServer.SupportInputMode();
  1324                 res = EFalse;
  1312                 }
  1325                 }
  1313             
       
  1314             TBool supportHWR = EFalse;
       
  1315             if(supportMode & EPluginInputModeHwr ||
       
  1316                supportMode & EPluginInputModeFSc ||
       
  1317                supportMode & EPluginInputModeFingerHwr)
       
  1318                 {
       
  1319                 supportHWR = ETrue;
       
  1320                 }
       
  1321             
       
  1322             res = ( !ChineseLanguage() && !JapaneseLanguage() && supportHWR);
  1326             }
  1323             }
  1327             break;
  1324             break;
  1328 
  1325 
  1329         case EGSInputpenIdRecognitionWithDictionary:
  1326         case EGSInputpenIdRecognitionWithDictionary:
  1330             {
  1327             {
  1331             res = EFalse;//item is useless after updating arabic hwr engine.
  1328             TInt currentLanguage = InputLanguage(); // add this line
  1332 //            TInt currentLanguage = InputLanguage(); // add this line
  1329             if (currentLanguage == ELangArabic)
  1333 //            if (currentLanguage == ELangArabic)
  1330                 {
  1334 //                {
  1331                 res = ETrue;
  1335 //                res = ETrue;
  1332                 }
  1336 //                }
       
  1337             }              
  1333             }              
  1338             break;   
  1334             break;   
  1339             
  1335             
  1340         case EGSInputpenIdWritingSpeed:
  1336         case EGSInputpenIdWritingSpeed:
  1341         case EGSInputpenIdPenTrailWidth:
  1337         case EGSInputpenIdPenTrailWidth:
  1342             {
       
  1343             if(IsSupportHWR())
       
  1344                 {
       
  1345                 res = ETrue;
       
  1346                 }
       
  1347             if(FeatureManager::FeatureSupported(KFeatureIdFfCapacitiveDisplay)&&
       
  1348                     iInputLanguage == ELangArabic)
       
  1349                 {//Hide item in setting list in arabic finger hwr.
       
  1350                 res = EFalse;
       
  1351                 }            
       
  1352             }
       
  1353             break;
       
  1354         case EGSInputpenIdPenTrailColour:
  1338         case EGSInputpenIdPenTrailColour:
  1355             {
  1339             {
  1356             if(IsSupportHWR())
  1340             TInt supportMode = EPluginInputModeNone;
       
  1341             if(KErrNone == iConnectErr)
       
  1342                 {
       
  1343                 supportMode = iPenInputServer.SupportInputMode();
       
  1344                 }
       
  1345                
       
  1346             if(supportMode & EPluginInputModeHwr ||
       
  1347                supportMode & EPluginInputModeFSc ||
       
  1348                supportMode & EPluginInputModeFingerHwr)
  1357                 {
  1349                 {
  1358                 res = ETrue;
  1350                 res = ETrue;
  1359                 }
  1351                 }
  1360             }
  1352             }
  1361             break;
  1353             break;
  1413            }
  1405            }
  1414        }    
  1406        }    
  1415     return EFalse;
  1407     return EFalse;
  1416     }
  1408     }
  1417 
  1409 
  1418 // ---------------------------------------------------------
       
  1419 // Check if support hwr.
       
  1420 // ---------------------------------------------------------
       
  1421 //
       
  1422 TBool CGSPenInputModel::IsSupportHWR()
       
  1423 	{
       
  1424 	TInt supportMode = EPluginInputModeNone;
       
  1425     if(KErrNone == iConnectErr)
       
  1426         {
       
  1427         supportMode = iPenInputServer.SupportInputMode( iInputLanguage );
       
  1428         }
       
  1429 
       
  1430     if( supportMode & EPluginInputModeHwr ||
       
  1431         supportMode & EPluginInputModeFSc ||
       
  1432         supportMode & EPluginInputModeFingerHwr)
       
  1433         {
       
  1434         return ETrue;
       
  1435         }    
       
  1436     return EFalse;
       
  1437 	}
       
  1438 
       
  1439 //  End Of File
  1410 //  End Of File