textinput/peninputarc/gsplugin/gspeninputplugin/src/gspeninputmodel.cpp
branchRCL_3
changeset 7 6defe5d1bd39
parent 0 eb1f2e154e89
child 8 4eb1ae11334f
equal deleted inserted replaced
6:6ceef9a83b1a 7:6defe5d1bd39
   791 
   791 
   792     MPtiLanguage* ptiLang = iPtiEngine->GetLanguage(iInputLanguage & KGSLanguageMask);    
   792     MPtiLanguage* ptiLang = iPtiEngine->GetLanguage(iInputLanguage & KGSLanguageMask);    
   793 
   793 
   794     if (iInputLanguage == ELangPrcChinese)
   794     if (iInputLanguage == ELangPrcChinese)
   795         {
   795         {
   796         if (aIndex == 0 && ptiLang->HasInputMode(EPtiEnginePinyinByPhrase))
   796         if( ptiLang != NULL )
   797             {
   797             {
   798             curInputMode = EPinyin;
   798             if (aIndex == 0 && ptiLang->HasInputMode(EPtiEnginePinyinByPhrase))
   799             }
   799                 {
   800         else
   800                 curInputMode = EPinyin;
   801             {
   801                 }
   802             curInputMode = EStroke;    
   802             else
       
   803                 {
       
   804                 curInputMode = EStroke;    
       
   805                 }
   803             }
   806             }
   804 
   807 
   805         if (curInputMode != -1)
   808         if (curInputMode != -1)
   806             {
   809             {
   807             iPersonalizationRepository->Set(KSettingsDefaultVkbPrc, curInputMode);
   810             iPersonalizationRepository->Set(KSettingsDefaultVkbPrc, curInputMode);
   808             iInputMode = curInputMode;   
   811             iInputMode = curInputMode;   
   809             }
   812             }
   810         }
   813         }
   811     else if (iInputLanguage == ELangHongKongChinese) 
   814     else if (iInputLanguage == ELangHongKongChinese) 
   812         {
   815         {
   813         if (aIndex == 0 && ptiLang->HasInputMode(EPtiEngineStrokeByPhrase))
   816         if( ptiLang != NULL )
   814             {
   817             {
   815             curInputMode = EStroke;
   818             if (aIndex == 0 && ptiLang->HasInputMode(EPtiEngineStrokeByPhrase))
   816             }
   819                 {
   817          else
   820                 curInputMode = EStroke;
   818             {
   821                 }
   819             curInputMode = ECangJie;   
   822             else
       
   823                 {
       
   824                 curInputMode = ECangJie;   
       
   825                 }
   820             }
   826             }
   821             
   827             
   822         if (curInputMode != -1)
   828         if (curInputMode != -1)
   823             {
   829             {
   824             iPersonalizationRepository->Set(KSettingsDefaultVkbHk, curInputMode);
   830             iPersonalizationRepository->Set(KSettingsDefaultVkbHk, curInputMode);
   825             iInputMode = curInputMode;   
   831             iInputMode = curInputMode;   
   826             }
   832             }
   827         }
   833         }
   828     else if (iInputLanguage == ELangTaiwanChinese)
   834     else if (iInputLanguage == ELangTaiwanChinese)
   829         { 
   835         { 
   830         if (aIndex == 0 && ptiLang->HasInputMode(EPtiEngineZhuyinByPhrase))
   836         if( ptiLang != NULL )
   831             {
   837             {
   832             curInputMode = EZhuyin;
   838             if (aIndex == 0 && ptiLang->HasInputMode(EPtiEngineZhuyinByPhrase))
   833             }
   839                 {
   834         else if (aIndex == 0 && ptiLang->HasInputMode(EPtiEngineStrokeByPhrase))
   840                 curInputMode = EZhuyin;
   835             {
   841                 }
   836             curInputMode = EStroke;
   842             else if (aIndex == 0 && ptiLang->HasInputMode(EPtiEngineStrokeByPhrase))
   837             }
   843                 {
   838         else if (aIndex == 0 && ptiLang->HasInputMode(EPtiEnginePinyinByPhrase))
   844                 curInputMode = EStroke;
   839             {
   845                 }
   840             curInputMode = EPinyin;
   846             else if (aIndex == 0 && ptiLang->HasInputMode(EPtiEnginePinyinByPhrase))
   841             }
   847                 {
   842         else if (aIndex == 1 && ptiLang->HasInputMode(EPtiEngineStrokeByPhrase))
   848                 curInputMode = EPinyin;
   843             {
   849                 }
   844             curInputMode = EStroke;
   850             else if (aIndex == 1 && ptiLang->HasInputMode(EPtiEngineStrokeByPhrase))
   845             }
   851                 {
   846         else if (aIndex == 1 && ptiLang->HasInputMode(EPtiEnginePinyinByPhrase))
   852                 curInputMode = EStroke;
   847             {
   853                 }
   848             curInputMode = EPinyin;
   854             else if (aIndex == 1 && ptiLang->HasInputMode(EPtiEnginePinyinByPhrase))
   849             }
   855                 {
   850         else if (aIndex == 2)
   856                 curInputMode = EPinyin;
   851             {
   857                 }
   852             curInputMode = EPinyin;            
   858             else if (aIndex == 2)
       
   859                 {
       
   860                 curInputMode = EPinyin;            
       
   861                 }
   853             }
   862             }
   854 
   863 
   855         if (curInputMode != -1)
   864         if (curInputMode != -1)
   856             {
   865             {
   857             iPersonalizationRepository->Set(KSettingsDefaultVkbTw, curInputMode);
   866             iPersonalizationRepository->Set(KSettingsDefaultVkbTw, curInputMode);
   867 TInt CGSPenInputModel::InputModeInSettingPage()
   876 TInt CGSPenInputModel::InputModeInSettingPage()
   868     {
   877     {
   869     TInt index = 0;
   878     TInt index = 0;
   870     TInt skipCount = 0;
   879     TInt skipCount = 0;
   871     MPtiLanguage* ptiLang = iPtiEngine->GetLanguage(iInputLanguage & KGSLanguageMask);    
   880     MPtiLanguage* ptiLang = iPtiEngine->GetLanguage(iInputLanguage & KGSLanguageMask);    
   872 
   881     
       
   882     if( ptiLang == NULL )
       
   883         {
       
   884         return index;
       
   885         }
   873     if (iInputLanguage == ELangPrcChinese)
   886     if (iInputLanguage == ELangPrcChinese)
   874         {
   887         {
   875         if (iInputMode == EPinyin && ptiLang->HasInputMode(EPtiEnginePinyinByPhrase))
   888         if (iInputMode == EPinyin && ptiLang->HasInputMode(EPtiEnginePinyinByPhrase))
   876             {
   889             {
   877             return index;
   890             return index;
   970     {
   983     {
   971     if ( !aInputModeItems )
   984     if ( !aInputModeItems )
   972         {
   985         {
   973         return;
   986         return;
   974         }
   987         }
   975         
   988     
   976     MPtiLanguage* ptiLang = iPtiEngine->GetLanguage(iInputLanguage & KGSLanguageMask);                
   989     MPtiLanguage* ptiLang = iPtiEngine->GetLanguage(iInputLanguage & KGSLanguageMask);    
       
   990     if( ptiLang == NULL )
       
   991         {
       
   992         return;
       
   993         }
   977     switch(iInputLanguage)
   994     switch(iInputLanguage)
   978         {
   995         {
   979         case ELangPrcChinese:
   996         case ELangPrcChinese:
   980             {            
   997             {            
   981             if(!ptiLang->HasInputMode(EPtiEngineStrokeByPhrase))
   998             if(!ptiLang->HasInputMode(EPtiEngineStrokeByPhrase))
  1226     TBool res = EFalse;    
  1243     TBool res = EFalse;    
  1227     switch( aItemId )
  1244     switch( aItemId )
  1228         {
  1245         {
  1229         case EGSInputpenIdHwrTraining:
  1246         case EGSInputpenIdHwrTraining:
  1230             {
  1247             {
  1231             iIsHwrTrainingAviliable = EFalse;
  1248             iIsHwrTrainingAviliable = EFalse;              
  1232             TInt supportMode = EPluginInputModeNone;
       
  1233             if(KErrNone == iConnectErr)
       
  1234                 {
       
  1235                 supportMode = iPenInputServer.SupportInputMode();
       
  1236                 }
       
  1237             TBool supportHWR = EFalse;
       
  1238             if(supportMode & EPluginInputModeHwr ||
       
  1239                supportMode & EPluginInputModeFSc ||
       
  1240                supportMode & EPluginInputModeFingerHwr)
       
  1241                 {
       
  1242                 supportHWR = ETrue;
       
  1243                 }
       
  1244               
       
  1245             CEikonEnv* env = CEikonEnv::Static();
  1249             CEikonEnv* env = CEikonEnv::Static();
  1246             TUid appUid = env->EikAppUi()
  1250             TUid appUid = env->EikAppUi()
  1247                           ->Application()->AppDllUid();
  1251                           ->Application()->AppDllUid();
  1248             if ( appUid == KUidPenInputSettingApp )
  1252             if ( appUid == KUidPenInputSettingApp )
  1249                 {
  1253                 {
  1256                 if ( parentUid == KUidtruiApp )
  1260                 if ( parentUid == KUidtruiApp )
  1257                    {
  1261                    {
  1258                     iIsHwrTrainingAviliable = EFalse;                    
  1262                     iIsHwrTrainingAviliable = EFalse;                    
  1259                     }
  1263                     }
  1260                 else
  1264                 else
  1261                        {
  1265                     {
  1262                     iIsHwrTrainingAviliable = IsTruiSupportedLanguage();
  1266                     iIsHwrTrainingAviliable = IsTruiSupportedLanguage();
  1263                        }
  1267                     }
  1264                    }                
  1268                 }                
  1265             else
  1269             else
  1266                 {
  1270                 {
  1267                 iIsHwrTrainingAviliable = IsTruiSupportedLanguage();
  1271                 iIsHwrTrainingAviliable = IsTruiSupportedLanguage();
  1268                 }
  1272                 }
  1269             res = ( !ChineseLanguage() && !JapaneseLanguage() && iIsHwrTrainingAviliable && supportHWR);
  1273             res = ( !ChineseLanguage() && !JapaneseLanguage() 
       
  1274             		&& iIsHwrTrainingAviliable 
       
  1275             		&& IsSupportHWR() );
  1270             }
  1276             }
  1271             break;
  1277             break;
  1272         case EGSInputpenIdInputLanguage:
  1278         case EGSInputpenIdInputLanguage:
  1273             {
  1279             {
  1274             res = ETrue;
  1280             res = ETrue;
  1286             }                        
  1292             }                        
  1287             break;
  1293             break;
  1288             
  1294             
  1289         case EGSInputpenIdGuidLine:
  1295         case EGSInputpenIdGuidLine:
  1290             {
  1296             {
  1291             TInt supportMode = EPluginInputModeNone;
  1297             res = ( !ChineseLanguage() && !JapaneseLanguage() && IsSupportHWR());
  1292             if(KErrNone == iConnectErr)
  1298             if(FeatureManager::FeatureSupported(KFeatureIdFfCapacitiveDisplay)&&
  1293                 {
  1299                     iInputLanguage == ELangArabic)
  1294                 supportMode = iPenInputServer.SupportInputMode();
  1300                 {
  1295                 }
  1301                 res = EFalse;
  1296             
  1302                 }
  1297             TBool supportHWR = EFalse;
       
  1298             if(supportMode & EPluginInputModeHwr ||
       
  1299                supportMode & EPluginInputModeFSc ||
       
  1300                supportMode & EPluginInputModeFingerHwr)
       
  1301                 {
       
  1302                 supportHWR = ETrue;
       
  1303                 }
       
  1304             
       
  1305             res = ( !ChineseLanguage() && !JapaneseLanguage() && supportHWR);
       
  1306             }
  1303             }
  1307             break;
  1304             break;
  1308 
  1305 
  1309         case EGSInputpenIdRecognitionWithDictionary:
  1306         case EGSInputpenIdRecognitionWithDictionary:
  1310             {
  1307             {
  1311             TInt currentLanguage = InputLanguage(); // add this line
  1308             res = EFalse;//item is useless after updating arabic hwr engine.
  1312             if (currentLanguage == ELangArabic)
  1309 //            TInt currentLanguage = InputLanguage(); // add this line
  1313                 {
  1310 //            if (currentLanguage == ELangArabic)
  1314                 res = ETrue;
  1311 //                {
  1315                 }
  1312 //                res = ETrue;
       
  1313 //                }
  1316             }              
  1314             }              
  1317             break;   
  1315             break;   
  1318             
  1316             
  1319         case EGSInputpenIdWritingSpeed:
  1317         case EGSInputpenIdWritingSpeed:
  1320         case EGSInputpenIdPenTrailWidth:
  1318         case EGSInputpenIdPenTrailWidth:
       
  1319             {
       
  1320             if(IsSupportHWR())
       
  1321                 {
       
  1322                 res = ETrue;
       
  1323                 }
       
  1324             if(FeatureManager::FeatureSupported(KFeatureIdFfCapacitiveDisplay)&&
       
  1325                     iInputLanguage == ELangArabic)
       
  1326                 {//Hide item in setting list in arabic finger hwr.
       
  1327                 res = EFalse;
       
  1328                 }            
       
  1329             }
       
  1330             break;
  1321         case EGSInputpenIdPenTrailColour:
  1331         case EGSInputpenIdPenTrailColour:
  1322             {
  1332             {
  1323             TInt supportMode = EPluginInputModeNone;
  1333             if(IsSupportHWR())
  1324             if(KErrNone == iConnectErr)
       
  1325                 {
       
  1326                 supportMode = iPenInputServer.SupportInputMode();
       
  1327                 }
       
  1328                
       
  1329             if(supportMode & EPluginInputModeHwr ||
       
  1330                supportMode & EPluginInputModeFSc ||
       
  1331                supportMode & EPluginInputModeFingerHwr)
       
  1332                 {
  1334                 {
  1333                 res = ETrue;
  1335                 res = ETrue;
  1334                 }
  1336                 }
  1335             }
  1337             }
  1336             break;
  1338             break;
  1388            }
  1390            }
  1389        }    
  1391        }    
  1390     return EFalse;
  1392     return EFalse;
  1391     }
  1393     }
  1392 
  1394 
       
  1395 // ---------------------------------------------------------
       
  1396 // Check if support hwr.
       
  1397 // ---------------------------------------------------------
       
  1398 //
       
  1399 TBool CGSPenInputModel::IsSupportHWR()
       
  1400 	{
       
  1401 	TInt supportMode = EPluginInputModeNone;
       
  1402     if(KErrNone == iConnectErr)
       
  1403         {
       
  1404         supportMode = iPenInputServer.SupportInputMode( iInputLanguage );
       
  1405         }
       
  1406 
       
  1407     TBool supportHWR = EFalse;
       
  1408     if( supportMode & EPluginInputModeHwr ||
       
  1409         supportMode & EPluginInputModeFSc ||
       
  1410         supportMode & EPluginInputModeFingerHwr)
       
  1411         {
       
  1412         return ETrue;
       
  1413         }    
       
  1414     return EFalse;
       
  1415 	}
       
  1416 
  1393 //  End Of File
  1417 //  End Of File