FCL/sf/app/contacts: comparison predictivesearch/PcsAlgorithm/Algorithm2/src/FindUtilChineseECE.cpp

equal deleted inserted replaced

-:2666d9724c76
+:d4f567ce2e7c
 #include <PtiEngine.h>
 #include <centralrepository.h>
 #include <AknFepInternalCRKeys.h>
 #include <aknedsts.h>
 #include <coeaui.h>
+#include <AvkonInternalCRKeys.h>
 // The below code is commented out because current CFindUtilChineseECE is used
 // on 3.2.3 which is not supported adaptive search. It will be easy to keep these code
 // for the further merging work (merge from FindUtil 5.0)
 #if 0
-#include <AvkonInternalCRKeys.h>
 #include <aknenv.h> //phonebook
 #include <aknappui.h>
 #include <aknapp.h>
 #include <eikenv.h>
 #include <eikapp.h>
 // CONSTANTS
 const TUint16 KStarChar = 0x002a;
 const TUint16 KZhuyinstart = 0x3105;
 const TInt KZhuyincount = 37;
 const TInt KSeperator = 2626;
-const TInt16 KMinUnicodeHz = 0x4e00;
+const TUint16 KMinUnicodeHz = 0x4e00;
-const TInt16 KStrokeHorizontalValue = 0x4e00;
+const TUint16 KMaxUnicodeHz = 0x9fa5;
-const TInt16 KStrokeVerticalValue = 0x4e28;
+const TUint16 KStrokeHorizontalValue = 0x4e00;
-const TInt16 KStrokeDownToLeftValue = 0x4e3f;
+const TUint16 KStrokeVerticalValue = 0x4e28;
-const TInt16 KStrokeDownToRightValue = 0x4e36;
+const TUint16 KStrokeDownToLeftValue = 0x4e3f;
-const TInt16 KStrokeBendingValue = 0x4e5b;
+const TUint16 KStrokeDownToRightValue = 0x4e36;
+const TUint16 KStrokeBendingValue = 0x4e5b;
 const TInt KSysInputMode = -1;
 const TInt KLeftToRightFlag =0x200e;
 const TInt KRightToLeftFlag =0x200f;
 // The below code is commented out because current CFindUtilChineseECE is used
 // on 3.2.3 which is not supported adaptive search. It will be easy to keep these code
 #if 0
 const TUid KUidPhoneBook = {0x101F4CCE};
 const TUid KUidPhoneBookServer = {0x10207277};
 #endif
 _LIT(KWildChar, "*");
 _LIT(KUnderLine, "_");
 _LIT(KMiddleLine, "-");
 _LIT(KBlank, " ");
 _LIT(KTab, "\t");
 _LIT(KPanicReason, "Abnormal input parameters!");
 const TInt KLitLineFeed(8233);
-// CleanupStack helpers for item owning RPointerArrays
-template <class T>
-class CleanupResetAndDestroy
-{
-public:
-inline static void PushL( T& aRef )
-{
-CleanupStack::PushL( TCleanupItem( &ResetAndDestroy, &aRef ) );
-}
-private:
-inline static void ResetAndDestroy( TAny *aPtr )
-{
-static_cast<T*>( aPtr )->ResetAndDestroy();
-}
-};
-template <class T>
-inline void CleanupResetAndDestroyPushL( T& aRef )
-{
-CleanupResetAndDestroy<T>::PushL( aRef );
-}
 // ======== MEMBER FUNCTIONS ========
 // ---------------------------------------------------------
 // Symbian constructor
 // ---------------------------------------------------------
 // ---------------------------------------------------------
 //
 void CFindUtilChineseECE::ConstructL(CPcsAlgorithm2* aAlgorithm)
 {
 iRepositoryFind = CRepository::NewL(KCRUidAknFep);
-// The below code is commented out because current CFindUtilChineseECE is used
-// on 3.2.3 which is not supported adaptive search. It will be easy to keep these code
-// for the further merging work (merge from FindUtil 5.0)
-#if 0
 iRepositoryFindAdaptive = CRepository::NewL(KCRUidAvkon);
-#endif
 iWatcher = CFindRepositoryWatcher::NewL(KCRUidAknFep,
 TCallBack(HandleFindRepositoryCallBack, this),
 iRepositoryFind);
-// The below code is commented out because current CFindUtilChineseECE is used
-// on 3.2.3 which is not supported adaptive search. It will be easy to keep these code
-// for the further merging work (merge from FindUtil 5.0)
-#if 0
 iWatcherAdaptive = CFindRepositoryWatcher::NewL(KCRUidAvkon,
 TCallBack(HandleFindRepositoryCallBack, this),
 iRepositoryFindAdaptive);
-#endif
 iAlgorithm = aAlgorithm;
 OpenL();
 }
 // CFindUtilChineseECE utils class
 // ---------------------------------------------------------
 //
 CFindUtilChineseECE::CFindUtilChineseECE() :
 iLanguage(ELangTest),
-iSupportPRCChinese(EFalse),
+iCurInputMode(KSysInputMode),
-iCurInputMode(KSysInputMode)
+iSearchMethod(EAdptSearchPinyin),
-// The below code is commented out because current CFindUtilChineseECE is used
-// on 3.2.3 which is not supported adaptive search. It will be easy to keep these code
-// for the further merging work (merge from FindUtil 5.0)
-#if 0
-iSearchMethodPRC(EAdptSearchPinyin),
-iSearchMethodTaiWan(EAdptSearchZhuyin),
-iSearchMethodHongKong(EAdptSearchStroke),
 iSearchMethodAdaptive(EFalse)
-#endif
+{
-	    {
+}
-	    }
 // ---------------------------------------------------------
 // Destructor
 // ---------------------------------------------------------
 //
 CFindUtilChineseECE::~CFindUtilChineseECE()
 {
 delete iPtiEngine;
 delete iWatcher;
-delete iPtiEnginePrc;
 delete iRepositoryFind;
-// The below code is commented out because current CFindUtilChineseECE is used
-// on 3.2.3 which is not supported adaptive search. It will be easy to keep these code
-// for the further merging work (merge from FindUtil 5.0)
-#if 0
 delete iWatcherAdaptive;
 delete iRepositoryFindAdaptive;
-#endif
 }
 // ---------------------------------------------------------
 // Open ptiengine and active it by input language
 // ---------------------------------------------------------
 TBool CFindUtilChineseECE::OpenT9InterfaceL(TLanguage aLanguage)
 {
 if (!iPtiEngine)
 {
 iPtiEngine = CPtiEngine::NewL();
-iSupportPRCChinese = IsSupportLanguage(ELangPrcChinese);
 }
 if (aLanguage != iLanguage)
 {
-iLanguage = aLanguage;
+// We only support Chinese languages. If input language is changed
+// to non-Chinese, then first available Chinese language is used
+// instead.
+if ( aLanguage == ELangPrcChinese ||
+aLanguage == ELangTaiwanChinese ||
+aLanguage == ELangHongKongChinese )
+{
+iLanguage = aLanguage;
+}
+else if ( IsSupportLanguage(ELangPrcChinese) )
+{
+iLanguage = ELangPrcChinese;
+}
+else if ( IsSupportLanguage(ELangTaiwanChinese) )
+{
+iLanguage = ELangTaiwanChinese;
+}
+else if ( IsSupportLanguage(ELangHongKongChinese) )
+{
+iLanguage = ELangHongKongChinese;
+}
+else
+{
+iLanguage = aLanguage;
+}
 iPtiEngine->ActivateLanguageL(iLanguage);
 iPtiEngine->EnableToneMarks(EFalse);
 }
 return ETrue;
 // Translate Chinese word to its spelling
 // ---------------------------------------------------------
 //
 TBool CFindUtilChineseECE::DoTranslationL(TInt16 aHZUnicode, RPointerArray<HBufC>& aSpellList)
 {
+// Always translate according the adaptive search method setting
+return T9ChineseTranslationAdaptiveL(aHZUnicode, aSpellList);
+#if 0
 // The below code is commented out because current CFindUtilChineseECE is used
 // on 3.2.3 which is not supported adaptive search. It will be easy to keep these code
 // for the further merging work (merge from FindUtil 5.0)
 #if 0
 if(CEikonEnv::Static())
 }
 }
 #endif
 return ETrue;
+#endif
 }
 // ---------------------------------------------------------
 // Find pane text is including stroke symbol
 // ---------------------------------------------------------
 //
-TInt CFindUtilChineseECE::IsStrokeSymbol(const TInt aFindWord)
+TInt CFindUtilChineseECE::IsStrokeSymbol(const TUint16 aFindWord)
 {
 TInt strokeValue = 0;
 switch (aFindWord)
 {
 }// switch
 return strokeValue;
 }
-TInt CFindUtilChineseECE::CategoryOfLang(TLanguage aLanguage)
+#if 0
-{
-TInt ret = 0;
-if (iLanguage == ELangPrcChinese || ( aLanguage == ELangEnglish && iSupportPRCChinese ))
-{
-ret = 1;
-}
-else if (aLanguage == ELangTaiwanChinese)
-{
-ret = 2;
-}
-else if (aLanguage == ELangHongKongChinese)
-{
-ret = 3;
-}
-return ret;
-}
 // ---------------------------------------------------------
 // Do translate for Chinese word
 // ---------------------------------------------------------
 //
 TBool CFindUtilChineseECE::T9ChineseTranslationL(TInt16 aHZUnicode, RPointerArray<HBufC>& aSpellList)
 {
 TBuf<KMaxWordInterpretationLen> wordInterpretationBuf;
-TBuf<KMaxWordInterpretationLen> numInterpretationBuf;
 if (iLanguage == ELangPrcChinese)
 {
 if (iPtiEngine->GetSpelling(aHZUnicode, wordInterpretationBuf, EPtiPinyin) != KErrNone)
 {
 aSpellList.Append((wordInterpretationBuf.MidTPtr(start, len - start)).Alloc());
 return ETrue;
 }
+#endif
-// The below code is commented out because current CFindUtilChineseECE is used
-// on 3.2.3 which is not supported adaptive search. It will be easy to keep these code
-// for the further merging work (merge from FindUtil 5.0)
-#if 0
 // ---------------------------------------------------------
 // Do translate for Chinese word
 // ---------------------------------------------------------
 //
 TBool CFindUtilChineseECE::T9ChineseTranslationAdaptiveL(TInt16 aHZUnicode,
 RPointerArray<HBufC>& aSpellList)
 {
 TBuf<KMaxWordInterpretationLen> wordInterpretationBuf;
-if ( iLanguage == ELangPrcChinese )
+switch(iSearchMethod)
 {
-if(iSearchMethodPRC == EAdptSearchPinyin)
+case EAdptSearchPinyin:
-{
+if (iPtiEngine->GetSpelling(aHZUnicode, wordInterpretationBuf, EPtiPinyin)
-if (iPtiEngine->GetSpelling(aHZUnicode, wordInterpretationBuf, EPtiPinyin)
 != KErrNone)
 {
 return EFalse;
 }
-}
+break;
-else if(iSearchMethodPRC == EAdptSearchStroke)
+case EAdptSearchStroke:
-{
+if (iPtiEngine->GetSpelling(aHZUnicode, wordInterpretationBuf, EPtiStrokes)
-if (iPtiEngine->GetSpelling(aHZUnicode, wordInterpretationBuf, EPtiStrokes)
 != KErrNone)
 {
 return EFalse;
 }
-}
+break;
-else
+case EAdptSearchZhuyin:
-{
+if (iPtiEngine->GetSpelling(aHZUnicode, wordInterpretationBuf, EPtiZhuyin)
-return EFalse;
-}
-}
-else if ( iLanguage == ELangTaiwanChinese )
-{
-if(iSearchMethodTaiWan == EAdptSearchZhuyin)
-{
-if (iPtiEngine->GetSpelling(aHZUnicode, wordInterpretationBuf, EPtiZhuyin)
 != KErrNone)
 {
 return EFalse;
 }
-}
+break;
-else if(iSearchMethodTaiWan == EAdptSearchStroke)
+case EAdptSearchNormalCangjie:
-{
+if (iPtiEngine->GetSpelling(aHZUnicode, wordInterpretationBuf, EPtiCangJie)
-if (iPtiEngine->GetSpelling(aHZUnicode, wordInterpretationBuf, EPtiStrokes)
 != KErrNone)
 {
 return EFalse;
 }
-}
+break;
-else
+case EAdptSearchEasyCangjie:
-{
+if (iPtiEngine->GetSpelling(aHZUnicode, wordInterpretationBuf, EPtiEasyCangjie)
-return EFalse;
+!= KErrNone)
-}
+{
-}
+return EFalse;
-else if ( iLanguage == ELangHongKongChinese )
+}
-{
+break;
-switch(iSearchMethodHongKong)
+case EAdptSearchAdvCangjie:
-{
+if ((iPtiEngine->GetSpelling(aHZUnicode, wordInterpretationBuf, EPtiCangJie) != KErrNone)
-case EAdptSearchNormalCangjie:
+&&(iPtiEngine->GetSpelling(aHZUnicode, wordInterpretationBuf, EPtiEasyCangjie) != KErrNone))
-if (iPtiEngine->GetSpelling(aHZUnicode, wordInterpretationBuf, EPtiCangJie)
+{
-!= KErrNone)
+return EFalse;
-{
+}
-return EFalse;
+break;
-}
+default:
-break;
-case EAdptSearchEasyCangjie:
-if (iPtiEngine->GetSpelling(aHZUnicode, wordInterpretationBuf, EPtiEasyCangjie)
-!= KErrNone)
-{
-return EFalse;
-}
-break;
-case EAdptSearchAdvCangjie:
-if ((iPtiEngine->GetSpelling(aHZUnicode, wordInterpretationBuf, EPtiCangJie) != KErrNone)
-&&(iPtiEngine->GetSpelling(aHZUnicode, wordInterpretationBuf, EPtiEasyCangjie) != KErrNone))
-{
-return EFalse;
-}
-break;
-case EAdptSearchStroke:
-if (iPtiEngine->GetSpelling(aHZUnicode, wordInterpretationBuf, EPtiStrokes)
-!= KErrNone)
-{
-return EFalse;
-}
-break;
-default:
-return EFalse;
-}
-}
-else if ( iLanguage == ELangEnglish )
-{
-if (!iSupportPRCChinese)
-{
 return EFalse;
 }
-TInt err = KErrNone;
-if (!iPtiEnginePrc)
-{
-iPtiEnginePrc = CPtiEngine::NewL(EFalse);
-TRAP(err, iPtiEnginePrc->ActivateLanguageL(ELangPrcChinese));
-}
-if (err == KErrNone)
-{
-if (iPtiEnginePrc->GetSpelling(aHZUnicode, wordInterpretationBuf, EPtiPinyin)
-!= KErrNone)
-return EFalse;
-}
-}
-else
-{
-return EFalse;
-}
 TInt len = wordInterpretationBuf.Length();
 TInt start = 0;
-if( iSearchMethodHongKong != EAdptSearchAdvCangjie )
+if( iSearchMethod != EAdptSearchAdvCangjie )
 {
 for (TInt i =0; i < len; i++)
 {
 if (wordInterpretationBuf[i] == KSeperator)
 {
 aSpellList.Append((wordInterpretationBuf.MidTPtr(start, i-start)).Alloc());
 start = i + 1;
 }
 }
 aSpellList.Append((wordInterpretationBuf.MidTPtr(start, len-start)).Alloc());
 }
 //Could look advanced cangjie as normal and easy cangjie
 else
 {
 iPtiEngine->GetSpelling(aHZUnicode, wordInterpretationBuf, EPtiEasyCangjie);
 aSpellList.Append((wordInterpretationBuf.MidTPtr(start, len-start)).Alloc());
 }
 return ETrue;
 }
-#endif
 // ---------------------------------------------------------
 // Find pane text is including separator
 // ---------------------------------------------------------
 //
 // ---------------------------------------------------------
 //
 void CFindUtilChineseECE::OpenL()
 {
 TInt inputLanguage = 0;
-//TInt searchMode =0;
+TInt searchMode = 0;
 if (iRepositoryFind != NULL)
 {
 iRepositoryFind->Get(KAknFepInputTxtLang, inputLanguage);
 }
+// The following sets iLangueage to inputLanguage if inputLanguage
+// is Chinese. If inputLanguage is non-Chinese, iLanguage will be
+// set to first available Chinese language.
 OpenT9InterfaceL((TLanguage) inputLanguage);
-// The below code is commented out because current CFindUtilChineseECE is used
-// on 3.2.3 which is not supported adaptive search. It will be easy to keep these code
-// for the further merging work (merge from FindUtil 5.0)
-#if 0
 if (iRepositoryFindAdaptive != NULL)
 {
 iRepositoryFindAdaptive->Get(KAknAvkonAdaptiveSearchEnabled, iSearchMethodAdaptive);
 }
-if( inputLanguage == ELangPrcChinese)
+if (iLanguage == ELangPrcChinese)
 {
 iRepositoryFindAdaptive->Get(KAknAdaptiveSearchChinesePRC , searchMode);
-if(searchMode ==0)
+if (searchMode == 0)
 {
-iSearchMethodPRC = EAdptSearchPinyin;
+iSearchMethod = EAdptSearchPinyin;
 }
-else if(searchMode ==1)
+else if (searchMode == 1)
 {
-iSearchMethodPRC = EAdptSearchStroke;
+iSearchMethod = EAdptSearchStroke;
 }
 }
-else if(inputLanguage == ELangTaiwanChinese)
+else if (iLanguage == ELangTaiwanChinese)
 {
 iRepositoryFindAdaptive->Get(KAknAdaptiveSearchChineseTW , searchMode);
-if(searchMode ==0)
+if (searchMode == 0)
 {
-iSearchMethodTaiWan = EAdptSearchZhuyin;
+iSearchMethod = EAdptSearchZhuyin;
 }
-else if(searchMode ==1)
+else if (searchMode == 1)
 {
-iSearchMethodTaiWan = EAdptSearchStroke;
+iSearchMethod = EAdptSearchStroke;
 }
 }
-else if(inputLanguage == ELangHongKongChinese)
+else if (iLanguage == ELangHongKongChinese)
 {
 iRepositoryFindAdaptive->Get(KAknAdaptiveSearchChineseHongkong  , searchMode);
-if(searchMode ==1)
+if (searchMode == 1)
 {
 iRepositoryFind->Get(KAknFepCangJieMode , searchMode);
 switch (searchMode)
 {
 case 0:
-iSearchMethodHongKong = EAdptSearchNormalCangjie;
+iSearchMethod = EAdptSearchNormalCangjie;
 break;
 case 1:
-iSearchMethodHongKong = EAdptSearchEasyCangjie;
+iSearchMethod = EAdptSearchEasyCangjie;
 break;
 case 2:
-iSearchMethodHongKong = EAdptSearchAdvCangjie;
+iSearchMethod = EAdptSearchAdvCangjie;
 break;
 }
+}
-}
+else if (searchMode == 0)
-else if(searchMode ==0)
+{
-{
+iSearchMethod = EAdptSearchStroke;
-iSearchMethodHongKong = EAdptSearchStroke;
+}
 }
-}
-#endif
 }
 // ---------------------------------------------------------
 // Close ptiEngine
 // ---------------------------------------------------------
 return EFalse;
 }
 TBool ret = EFalse;
 // Check Chinese word in find pane
-TBool chineseWord = IsChineseWord(aWord);
+TBool chineseWord = IsChineseWordIncluded(aWord);
 if (chineseWord)
 {
 ret = IncludeString(aContactsField, aWord);
 // Match arithmetic for accurate search
 // ---------------------------------------------------------
 //
 TBool CFindUtilChineseECE::MatchRefineL(const TDesC& aItemString, CPsQuery& aPsQuery)
 {
+RArray<TInt> ignore1;
+CleanupClosePushL( ignore1 );
+RArray<TInt> ignore2;
+CleanupClosePushL( ignore2 );
+TBool match = MatchRefineL( aItemString, aPsQuery, ignore1, ignore2, EFalse );
+CleanupStack::PopAndDestroy( &ignore2 );
+CleanupStack::PopAndDestroy( &ignore1 );
+return match;
+}
+TBool CFindUtilChineseECE::MatchRefineL(const TDesC& aItemString, CPsQuery& aPsQuery,
+RArray<TInt>& aMatchPos, RArray<TInt>& aMatchLength, TBool aHighLight )
+{
 TBuf<KMaxWordLength> tempBuf;
 TBuf<KMaxWordLength> itemString;
+TBool haschineseword = EFalse;
 itemString.Zero();
 if ( KMaxWordLength > aItemString.Length() )
 {
 itemString.Copy( aItemString );
 if(itemString.Length()>0)
 {
 if(itemString[0]== KLeftToRightFlag || itemString[0]== KRightToLeftFlag)
 {
 itemString.Delete(0,1);
 itemString.Delete((itemString.Length()-1),1);
 }
 }
-TBool haschineseword = EFalse;
 // Check function parameter
 if (aPsQuery.Count() == 0)
 {
 return ETrue;
 {
 return EFalse;
 }
 TBool ret = EFalse;
 CPsQuery* query = CPsQuery::NewL();
+CleanupStack::PushL( query );
 GetPartOfQueryL(aPsQuery, 0, aPsQuery.Count()-1, *query);
 RemoveSeparatorL(*query);
 TPtrC queryStrPtr = query->QueryAsStringLC();
 tempBuf.Zero();
 }
 else
 {
 iCurInputMode = KSysInputMode;
 }
-// Check Chinese word in find pane
+TBool inputMethodStroke = EFalse;
-if (IsChineseWord(tempBuf))
+if(iLanguage == ELangHongKongChinese && iCurInputMode == 0x0020)
+{
+inputMethodStroke = ETrue;
+}
+// Check if any Chinese word in find pane
+if ( IsChineseWordIncluded(tempBuf) )
 {
 haschineseword = ETrue;
 ret = IncludeString(aItemString, tempBuf);
-if (ret)
+if( IsAllChineseWord( tempBuf ))
 {
+CleanupStack::PopAndDestroy( query );
 return ret;
 }
-/*    else
+}
-{
-// if Stroke Symbol in HongKong
-TBool strokeSymHK = (IsStrokeSymbolInString(tempBuf)) &&
+// There are two steps to do when searchstring includes Chinese character
-(iLanguage == ELangHongKongChinese) &&
+//
-iCurInputMode == 0x0020;
+// step 1:  check whether itemstring includes the chinese charactor in the searchstring
+//              If not, return EFalse. Otherwise, go to step2
-if (!strokeSymHK)
+//
-{
+// step2:  If itemstring includes the chinese charactor in the searchstring, translate
-return ret;
+//             the Chinese character in the searchstring to spellList and reconstruct the query.
-}
-}*/
-}
-//Find if search string has chinese word.
-//Compare with item string if find chinese word in item string then delete it from search and item string.
-//if not then return EFalse.
-TBool InputMethodStroke = EFalse;
-if(iLanguage == ELangHongKongChinese && iCurInputMode == 0x0020)
-{
-InputMethodStroke = ETrue;
-}
 if (haschineseword)
 {
 TInt ii=0;
-TBool leftDifferentChinese = EFalse; //Fixed for ESSG-7PJ6GF, flag the different Chinese character at the left of aSearchText.
+// Step 1:
+// E.g: itemstring = "0x4E00,0x4E8C,0x4E09,0x56DB,0x4E94"
+// (Unicode of Chinese number "1 2 3 4 5")
+// searchstring1 = "0x4E00,x,y,z,0x4E09"
+// searchstring2 = "0x4E8C,0x4E00"
+// searchstring3 = "0x4E00,0x4E5D"
+// In this case, searchstring2 and searchstring3 will return EFalse,
+// only searchstring1 will be translated to spellList in step 2
 while (ii< tempBuf.Length())
 {
-if ((TInt)tempBuf[ii]>= KMinUnicodeHz && (!InputMethodStroke
+TInt lastFindCursor = -1;
-||(InputMethodStroke && !IsStrokeSymbol(tempBuf[ii]))))
+if( (TUint16)tempBuf[ii] <= KMaxUnicodeHz
+&& (TUint16)tempBuf[ii]>= KMinUnicodeHz
+&& ( !inputMethodStroke ||(inputMethodStroke &&
+!IsStrokeSymbol(tempBuf[ii])) ) )
 {
 TInt Findcursor = itemString.Locate(tempBuf[ii]);
-if (Findcursor != KErrNotFound)
+if( KErrNotFound == Findcursor || Findcursor < lastFindCursor )
 {
-if ((Findcursor == itemString.Length()-1)&& (ii
+CleanupStack::PopAndDestroy( query );
-==tempBuf.Length()-1))
+return EFalse;
-{
-//Start:Fixed for ESSG-7PJ6GF
-if ( leftDifferentChinese || IsChineseWord(
-itemString.Left( Findcursor ) ) )
-{
-//if the different Chinese character at the left or middle, return false.
-return EFalse;
-}
-//End:Fixed for ESSG-7PJ6GF
-return ETrue;
-}
-itemString.Delete(0, Findcursor+1);
-tempBuf.Delete(0, ii+1);
-ii=0;
 }
 else
 {
-//Start:Fixed for ESSG-7PJ6GF
+lastFindCursor = Findcursor;
-if ( IsChineseWord( tempBuf.Left( ii + 1 ) ) )
-{
-//flag the different Chinese character at the left.
-leftDifferentChinese = ETrue;
-}
-//End:Fixed for ESSG-7PJ6GF
 ii++;
 }
 }
 else
 {
 ii++;
 }
 }
-}
+ii = 0;
+// Counter of queryItem
+TInt queryItemCount = 0;
+//Step 2:
+// Translating searchstring to spellList and reconstruct query
+while ( ii< tempBuf.Length() )
+{
+// If it is a valid chinese character
+if ( (TUint16)tempBuf[ii] <= KMaxUnicodeHz
+&& (TUint16)tempBuf[ii]>= KMinUnicodeHz
+&& ( !inputMethodStroke ||(inputMethodStroke &&
+!IsStrokeSymbol(tempBuf[ii])) ) )
+{
+RPointerArray<HBufC> spellList;
+// If successfully translating the chinese character to spellList( Pinyin,Zhuyin or stroke )
+// then reconstruct the query, replace the Chinese character with its spellList in the query.
+// Otherwise, just increase the counter of queryItem.
+if( DoTranslationL(TInt16(tempBuf[ii]), spellList) )
+{
+// Replace the queryItem by the translated spelling
+CPsQueryItem& tempItem = query->GetItemAtL(queryItemCount);
+const TKeyboardModes tempMode = tempItem.Mode();
+// Remove the Chinese character queryItem
+query->Remove(queryItemCount);
+// Reconstruct the query, replace Chinese character with its spellList
+for(TInt cnt = 0; cnt < spellList[0]->Length(); cnt++)
+{
+// Add a new query item to query
+CPsQueryItem* newItem = CPsQueryItem::NewL();
+CleanupStack::PushL(newItem);
+newItem->SetCharacter(  (*spellList[0])[cnt] );
+newItem->SetMode(tempMode);
+query->InsertL(*newItem, queryItemCount + cnt );
+CleanupStack::Pop(newItem);
+}
+queryItemCount += spellList[0]->Length();
+}
+else
+{
+queryItemCount++;
+}
+ii++;
+spellList.ResetAndDestroy();
+spellList.Close();
+}
+//if not, just pass it by
+else
+{
+ii++;
+queryItemCount++;
+}
+}
+}
 // Array for item string
 RPointerArray<STRINGINFO> stringInfoArr;
 // Split item string
 SplitItemStringL(stringInfoArr, itemString);
 if (stringInfoArr.Count() > 0)
 {
-ret = MatchSegmentL(stringInfoArr, *query);
+ret = MatchSegmentL(stringInfoArr, *query, aMatchPos, aMatchLength, aHighLight);
 }
 stringInfoArr.ResetAndDestroy();
 stringInfoArr.Close();
-delete query;
+CleanupStack::PopAndDestroy( query );
 return ret;
 }
 // ---------------------------------------------------------
 // Splite the input text to sgement by language
 // ---------------------------------------------------------
 //
 void CFindUtilChineseECE::SplitItemStringL(RPointerArray<STRINGINFO>& aStringInfoArr,
-const TDesC &aItemString)
+const TDesC& aItemString)
 {
 TBuf<KMaxWordLength> tempBuf;
 TBuf<KMaxWordLength> englishBuf;
 TBuf<KMaxWordLength> chineseBuf;
 tempBuf.Zero();
 englishBuf.Zero();
 chineseBuf.Zero();
 TInt index = 0;
-TUint32 temp = 0;
+TBool isChinese = EFalse;
-TInt32 distance = 0;
 const TInt strLength = aItemString.Length();
 for (; index < strLength; index++)
 {
 if (IsFindWordSeparator(aItemString[index]))
 {
 // Check Chinese and English Buf. If it is not empty,
 // add buf to Array
-InsertStrInforArrayL(aStringInfoArr, chineseBuf, ETrue);
+InsertStrInforArrayL(aStringInfoArr, chineseBuf, ETrue, index);
-InsertStrInforArrayL(aStringInfoArr, englishBuf, EFalse);
+InsertStrInforArrayL(aStringInfoArr, englishBuf, EFalse, index);
 continue;
 }
-temp = aItemString[index];
+isChinese = ((TUint16)aItemString[index] >= KMinUnicodeHz &&
-distance = (TInt32)(temp - KMinUnicodeHz);
+(TUint16)aItemString[index] <= KMaxUnicodeHz);
-if (distance < 0)// English word
+if ( !isChinese )// English word
 {
 // Chinese word is end and add to array
-InsertStrInforArrayL(aStringInfoArr, chineseBuf, ETrue);
+InsertStrInforArrayL(aStringInfoArr, chineseBuf, ETrue, index);
 // Add English word to array
-englishBuf.Append((TChar) aItemString[index]);
+englishBuf.Append(aItemString[index]);
 }
 else // Chinese word
 {
 // English word is end and add to array
-InsertStrInforArrayL(aStringInfoArr, englishBuf, EFalse);
+InsertStrInforArrayL(aStringInfoArr, englishBuf, EFalse, index);
 // Add Chinese word to array
-chineseBuf.Append((TChar) aItemString[index]);
+chineseBuf.Append(aItemString[index]);
 }
 }
 // Finish loop check buffer is empty
-InsertStrInforArrayL(aStringInfoArr, chineseBuf, ETrue);
+InsertStrInforArrayL(aStringInfoArr, chineseBuf, ETrue, index);
-InsertStrInforArrayL(aStringInfoArr, englishBuf, EFalse);
+InsertStrInforArrayL(aStringInfoArr, englishBuf, EFalse, index);
 }
 // ---------------------------------------------------------
 // Insert segment to list
 // ---------------------------------------------------------
 //
 void CFindUtilChineseECE::InsertStrInforArrayL(RPointerArray<STRINGINFO>& aStringInfoArr,
-TDes &aSegmentStr, const TBool aChinese)
+TDes &aSegmentStr, TBool aChinese, TInt aIndexAfterStr)
 {
-CleanupResetAndDestroyPushL( aStringInfoArr );
 if (aSegmentStr.Length() <= 0)
 {
 return;
 }
 strInfo->segmentString.Zero();
 strInfo->segmentString.Copy(aSegmentStr);
 strInfo->segmentString.LowerCase();
 strInfo->isChinese = aChinese;
+strInfo->segmentPos = aIndexAfterStr - aSegmentStr.Length();
 aStringInfoArr.AppendL(strInfo);
 aSegmentStr.Zero();
-CleanupStack::Pop( &aStringInfoArr );
 }
 // ---------------------------------------------------------
 // This segment is matched by search text
 // ---------------------------------------------------------
 //
 TBool CFindUtilChineseECE::MatchSegmentL(RPointerArray<STRINGINFO>& aStringInfoArr,
-CPsQuery& aQuery)
+CPsQuery& aQuery, RArray<TInt>& aMatchPos, RArray<TInt>& aMatchLength, TBool aHighLight )
 {
 const TInt arrayLength = aStringInfoArr.Count();
 const TInt searchStrLength = aQuery.Count();
-TInt searchStrIndex = 0;
 STRINGINFO* pStringInfo;
 TInt index = 0;
+TBool ret = EFalse;
-// First only check English
+TBool hasChinese = EFalse;
+// First check if there is a full match in non-Chinese in any one segment
 for (; index < arrayLength; index++)
+{
+pStringInfo = aStringInfoArr[index];
+TPtrC currentSeg( pStringInfo->segmentString );
+TInt matchLen( 0 );
+// Compare word
+if (pStringInfo->isChinese)
+{
+hasChinese = ETrue;
+}
+else
+{
+matchLen = MatchStringL( currentSeg, aQuery );
+}
+// If full match is found
+if ( matchLen == searchStrLength  )
+{
+//Only append postion of non-Chinese character
+if(  !pStringInfo->isChinese )
+{
+aMatchPos.Append( pStringInfo->segmentPos );
+aMatchLength.Append( matchLen );
+}
+ret =   ETrue;
+// If there is no need to HighLight the matched part, return immediately
+// Otherwise, continue to find all the matched positions
+if( !aHighLight )
+return ret;
+}
+}
+// Then search through segments again, this time considering
+// also cases where matching part continues over several segments.
+// This algorithm is greedy and heuristic and can't necesarily find
+// all the matches in the segments after the first one.
+TPtrC segCurrent;
+TInt searchStrIndextemp = 0;
+TInt searchStrIndexMax = 0;
+TInt searchStrIndex = 0;
+index = 0;
+// Loop through seqments until whole query is matched
+for (; index < arrayLength && !ret ; index++)
 {
 // Create an empty CPsQuery
 CPsQuery* tempQuery = CPsQuery::NewL();
+CleanupStack::PushL( tempQuery );
+GetPartOfQueryL( aQuery, searchStrIndex, searchStrLength - 1, *tempQuery );
 pStringInfo = aStringInfoArr[index];
+segCurrent.Set( pStringInfo->segmentString );
-GetPartOfQueryL( aQuery, searchStrIndex, searchStrLength - 1,
-*tempQuery );
+if (pStringInfo->isChinese)
+{
-// Compare word
+// find the longest substring matching the query
-if (!pStringInfo->isChinese)
+searchStrIndexMax = 0;
-{
+for (TInt i = 0; i< segCurrent.Length(); i++)
-searchStrIndex += MatchString(pStringInfo->segmentString, *tempQuery);
+{
-}
+TPtrC tempSeg( segCurrent.Mid(i) );
+TInt startIdx( KErrNotFound );
-delete tempQuery;
+TInt endIdx( KErrNotFound );
-tempQuery = NULL;
+searchStrIndextemp = MatchChineseStringL(tempSeg, *tempQuery, startIdx, endIdx);
+if (searchStrIndextemp > searchStrIndexMax)
-if (searchStrIndex >= searchStrLength)
-{
-return ETrue;
-}
-}
-TBuf<KMaxWordLength> bufcurrent;
-TBuf<KMaxWordLength> tempbufcurrent;
-TInt searchStrIndextemp = 0;
-TInt searchStrIndexMax = 0;
-// Find Chinese and English
-searchStrIndex = 0;
-index = 0;
-for (; index < arrayLength; index++)
-{
-// Create an empty CPsQuery
-CPsQuery* tempQuery = CPsQuery::NewL();
-pStringInfo = aStringInfoArr[index];
-GetPartOfQueryL( aQuery, searchStrIndex, searchStrLength - 1,
-*tempQuery );
-searchStrIndexMax = 0;
-bufcurrent = pStringInfo->segmentString;
-for(TInt i =0;i< pStringInfo->segmentString.Length();i++)
-{
-tempbufcurrent = bufcurrent.Mid(i);
-if (pStringInfo->isChinese)
-{
-TInt temp=0;
-searchStrIndextemp = MatchChineseStringL(tempbufcurrent, *tempQuery, temp);
-if(searchStrIndextemp > searchStrIndexMax)
 {
 searchStrIndex -= searchStrIndexMax;
 searchStrIndexMax = searchStrIndextemp;
 searchStrIndex += searchStrIndexMax;
 }
-}
-else
+if (searchStrIndex >= searchStrLength)
 {
-searchStrIndex += MatchString(pStringInfo->segmentString, *tempQuery);
+// found substring which consumes whole query, no need to find any longer
-}
+break;
+}
-if (searchStrIndex >= searchStrLength)
+}
-{
+}
-delete tempQuery;
+else // not chinese
-tempQuery = NULL;
+{
-return ETrue;
+TInt matchLen = MatchStringL(segCurrent, *tempQuery);
-}
+searchStrIndex += matchLen;
-else if(!pStringInfo->isChinese)
+if ( matchLen )
 {
-break;
+aMatchPos.Append( pStringInfo->segmentPos );
-}
+aMatchLength.Append( matchLen );
 }
+}
-delete tempQuery;
-tempQuery = NULL;
+if (searchStrIndex >= searchStrLength)
-}
+{
+ret = ETrue; // also breaks us out from the loop
-return EFalse;
+}
+else if ( !pStringInfo->isChinese && !hasChinese )
+{
+CleanupStack::PopAndDestroy( tempQuery );
+break;
+}
+CleanupStack::PopAndDestroy( tempQuery );
+}
+return ret;
 }
 // ---------------------------------------------------------
 // Search Chinese word in input text
 // ---------------------------------------------------------
 //
-TInt CFindUtilChineseECE::MatchChineseStringL(const TDesC& aSearhTargetString, CPsQuery& aQuery, TInt& aIndex)
+TInt CFindUtilChineseECE::MatchChineseStringL(const TDesC& aSearhTargetString, CPsQuery& aQuery,
+TInt& aMatchStartIdx, TInt& aMatchEndIdx)
 {
 const TInt stringLength = aSearhTargetString.Length();
 const TInt searchLength = aQuery.Count();
 TInt index = 0;
-//TBuf<KMaxWordLength> tempBuf;
 TBuf<KMaxWordLength> previousBuf;
 TInt curMatchCount = 0;
 TInt preMatchCount = 0;
 TInt matchIndex = 0;
 TInt curSearchIndex = 0;
 TBool bFullMatched = EFalse;
 TBool bContinue = EFalse;
+TBool bPrevReplaced = EFalse;
+aMatchStartIdx = KErrNotFound;
+aMatchEndIdx = KErrNotFound;
+CPsQuery* tempFullQuery = CPsQuery::NewL();
+CleanupStack::PushL( tempFullQuery );
+GetPartOfQueryL( aQuery, 0, aQuery.Count() - 1, *tempFullQuery );
 for (; index < stringLength; index++)
 {
 RPointerArray<HBufC> spellList;
 matchIndex = 0;
 bContinue = EFalse;
 // Get left string
 CPsQuery* tempQuery = CPsQuery::NewL();
-GetPartOfQueryL( aQuery, curSearchIndex, searchLength - 1,
+CleanupStack::PushL( tempQuery );
-*tempQuery );
+GetPartOfQueryL( aQuery, curSearchIndex, searchLength - 1, *tempQuery );
 // Get Matched count and the matched index in list
-curMatchCount = MaxMatchInList(spellList, *tempQuery, previousBuf, matchIndex,
+curMatchCount = MaxMatchInListL(spellList, *tempQuery, previousBuf, matchIndex,
-bFullMatched, preMatchCount, bContinue);
+bFullMatched, preMatchCount, bContinue, bPrevReplaced, *tempFullQuery);
 // There is a string matched in list
 if (curMatchCount != 0)
 {
-previousBuf.Copy(spellList[matchIndex]->Des());
+previousBuf.Copy(*spellList[matchIndex]);
 if (curMatchCount == previousBuf.Length())
 {
 bFullMatched = ETrue;
 }
 else
 {
 bFullMatched = EFalse;
 }
 // If it is repeat match, continue
 if (!bContinue)
 {
 curSearchIndex += curMatchCount;
 }
 else
 {
 bFullMatched = EFalse;
 previousBuf.Zero();
 curMatchCount = 0;
 }
+// Store the index of first matched Han character
+if ( bPrevReplaced || aMatchStartIdx == KErrNotFound )
+{
+aMatchStartIdx = index;
+}
+// Store the index of last matched Han character
+aMatchEndIdx = index;
 }
 else
 {
 bFullMatched = EFalse;
 previousBuf.Zero();
 {
 index--;
 }
 curSearchIndex = 0;
+// Any earlier partial match is discarded, reset the matching part indices
+aMatchStartIdx = KErrNotFound;
+aMatchEndIdx = KErrNotFound;
 }
 spellList.ResetAndDestroy();//destroy spellList
 spellList.Close();
 preMatchCount = curMatchCount;
-delete tempQuery;
+CleanupStack::PopAndDestroy( tempQuery );
 tempQuery = NULL;
 // Search to End and return
 if (curSearchIndex >= searchLength)
 {
 break;
 }
 }
+CleanupStack::PopAndDestroy( tempFullQuery );
-aIndex = index;
+tempFullQuery = NULL;
 return curSearchIndex;
 }
 // ---------------------------------------------------------
 // Maximal matched count in spelling list
 // ---------------------------------------------------------
 //
-TInt CFindUtilChineseECE::MaxMatchInList(RPointerArray<HBufC> &spellList, CPsQuery& aQuery,
+TInt CFindUtilChineseECE::MaxMatchInListL(RPointerArray<HBufC> &aSpellList, CPsQuery& aQuery,
 TDesC& aPreviouStr, TInt& aMatchIndex, const TBool aFullMatched,
-const TInt aMatchedCount, TBool& aAgain)
+const TInt aMatchedCount, TBool& aAgain, TBool& aPrevReplaced, CPsQuery& aFullQuery)
 {
-const TInt itemCount = spellList.Count();
+const TInt itemCount = aSpellList.Count();
 TInt matchCount = 0;
 TBool selfMatch = EFalse;
 aMatchIndex = 0;
 // If list is empty, then return
 {
 temp = 0;
 repeatCount = 0;
 loopFlag = EFalse;
 tempBuf.Zero();
-tempBuf.Copy(spellList[index]->Des());
+tempBuf.Copy( *aSpellList[index] );
-temp = MatchString(tempBuf, aQuery);
+temp = MatchStringL(tempBuf, aQuery);
 if(temp != 0)
 {
 selfMatch = ETrue;
 }
 else
 if (temp == 0 && aPreviouStr.Length() != 0)
 {
 // Previous word is fully matched
 if (aFullMatched)
 {
-repeatCount = ReverseMatchString(aPreviouStr, tempBuf);
+repeatCount = ReverseMatchStringL(aPreviouStr, tempBuf, aFullQuery );
 // Find repeat and remove it, search again
 if (repeatCount != 0)
 {
-temp = MatchString(tempBuf.Right(tempBuf.Length() - repeatCount), aQuery);
+temp = MatchStringL(tempBuf.Right(tempBuf.Length() - repeatCount), aQuery);
 if (temp == 0)
 {
 loopFlag = ETrue;
 temp = repeatCount;
 }
 }
 }
 else
 {
-repeatCount = MatchString(aPreviouStr, tempBuf);
+repeatCount = MatchStringL(aPreviouStr, tempBuf, aFullQuery);
 // Find repeat and remove it, search again
 if (repeatCount != 0)
 {
 if (aMatchedCount <= repeatCount)
 {
-temp = MatchString(tempBuf.Right(tempBuf.Length() - aMatchedCount), aQuery);
+temp = MatchStringL(tempBuf.Right(tempBuf.Length() - aMatchedCount), aQuery);
 if (temp == 0)
 {
 loopFlag = ETrue;
 temp = aMatchedCount;
 }
 }
 if (temp == 0)
 {
-repeatCount = ReverseMatchString(aPreviouStr.Left(aMatchedCount), tempBuf);
+repeatCount = ReverseMatchStringL(aPreviouStr.Left(aMatchedCount), tempBuf, aFullQuery);
 if (repeatCount != 0)
 {
-temp = MatchString(tempBuf.Right(tempBuf.Length() - repeatCount), aQuery);
+temp = MatchStringL(tempBuf.Right(tempBuf.Length() - repeatCount), aQuery);
 if (temp == 0)
 {
 loopFlag = ETrue;
 temp = repeatCount;
 {
 matchCount = temp;
 aMatchIndex = index;
 aAgain = loopFlag;
 }
-if(matchCount == aQuery.Count() && selfMatch)
+if (matchCount == aQuery.Count() && selfMatch)
 {
 break;
 }
 }
+// Was the previous match replaced with a longer match from this spell list
+aPrevReplaced = ( matchCount && repeatCount );
 return matchCount;
 }
 // ---------------------------------------------------------
-// Search the taxt is include the input text
+// Search the text is include the input text
 // ---------------------------------------------------------
 //
 TBool CFindUtilChineseECE::IncludeString(const TDesC& aFirst, const TDesC& aSecond)
 {
 TBuf<KMaxWordLength> tempBuf;
 // ---------------------------------------------------------
 // Search text in other text
 // ---------------------------------------------------------
 //
-TInt CFindUtilChineseECE::MatchString(const TDesC& aFirst, const TDesC& aSecond)
+TInt CFindUtilChineseECE::MatchStringL(const TDesC& aFirst, const TDesC& aSecond, CPsQuery& aFullQuery)
 {
 const TInt secondStrLength = aSecond.Length();
 const TInt firstStrLength = aFirst.Length();
-const TInt compareCount = firstStrLength > secondStrLength ? secondStrLength
+const TInt compareCount = Min( firstStrLength, secondStrLength );
-: firstStrLength;
 TInt index = 0;
+TBuf<KMaxWordInterpretationLen> firstNumInterpretationBuf;
-TBuf<KMaxWordLength> tempStr;
+TBuf<KMaxWordInterpretationLen> secondNumInterpretationBuf;
-// translate search target string into numeric string before match
-if (iAlgorithm)
+iAlgorithm->GetKeyMap()->GetMixedKeyStringForDataL(aFullQuery, aFirst, firstNumInterpretationBuf);
-{
+iAlgorithm->GetKeyMap()->GetMixedKeyStringForDataL(aFullQuery, aSecond, secondNumInterpretationBuf);
-iAlgorithm->Converter( aFirst, tempStr );
-}
-else
-{
-tempStr.Copy(aFirst);
-}
 for (; index < compareCount; index++)
 {
-if (tempStr.Left(index + 1).FindC(aSecond.Left(index + 1)) == KErrNotFound)
+if (firstNumInterpretationBuf.Left(index + 1).FindC(secondNumInterpretationBuf.Left(index + 1)) == KErrNotFound)
 {
 break;
 }
 }
 // Match count
 return index;
 }
 // ---------------------------------------------------------
 // Search CPsQuery in aSearhTargetStr
 // ---------------------------------------------------------
 //
-TInt CFindUtilChineseECE::MatchString(const TDesC& aSearhTargetStr, CPsQuery& aQuery)
+TInt CFindUtilChineseECE::MatchStringL(const TDesC& aSearhTargetStr, CPsQuery& aQuery)
 {
 const TInt secondStrLength = aQuery.Count();
 const TInt firstStrLength = aSearhTargetStr.Length();
 TBuf<KMaxWordInterpretationLen> numInterpretationBuf;
+TBuf<KMaxWordInterpretationLen> queryStr;
-const TInt compareCount = firstStrLength > secondStrLength ? secondStrLength
-: firstStrLength;
+const TInt compareCount = Min( firstStrLength, secondStrLength );
 TInt index = 0;
-ConvertdDataToKeyBoardModeL(aQuery, aSearhTargetStr, numInterpretationBuf);
+iAlgorithm->GetKeyMap()->GetMixedKeyStringForDataL(aQuery, aSearhTargetStr, numInterpretationBuf);
+iAlgorithm->GetKeyMap()->GetMixedKeyStringForQueryL(aQuery, queryStr);
-TPtrC queryStr = aQuery.QueryAsStringLC();
 for (; index < compareCount; index++)
 {
 if (numInterpretationBuf.Left(index + 1).FindC(queryStr.Left(index + 1)) == KErrNotFound)
 {
 break;
 }
 }
-CleanupStack::PopAndDestroy();
 // Match count
 return index;
 }
 // ---------------------------------------------------------
 // Search text by reverse
 // ---------------------------------------------------------
 //
-TInt CFindUtilChineseECE::ReverseMatchString(const TDesC& aFirst, const TDesC& aSecond)
+TInt CFindUtilChineseECE::ReverseMatchStringL(const TDesC& aFirst, const TDesC& aSecond, CPsQuery& aFullQuery)
 {
 const TInt secondStrLength = aSecond.Length();
 const TInt firstStrLength = aFirst.Length();
 TInt compareCount = firstStrLength > secondStrLength ? secondStrLength : firstStrLength;
 TInt index = 0;
 TInt matchCount = 0;
+TBuf<KMaxWordInterpretationLen> firstNumInterpretationBuf;
+TBuf<KMaxWordInterpretationLen> secondNumInterpretationBuf;
+iAlgorithm->GetKeyMap()->GetMixedKeyStringForDataL(aFullQuery, aFirst, firstNumInterpretationBuf);
+iAlgorithm->GetKeyMap()->GetMixedKeyStringForDataL(aFullQuery, aSecond, secondNumInterpretationBuf);
 for (; index < compareCount; index++)
 {
-TBuf<KMaxWordLength> firstConvStr;
+if( firstNumInterpretationBuf.Right( index + 1 ).FindC( secondNumInterpretationBuf.Left( index + 1 ) ) != KErrNotFound )
-TBuf<KMaxWordLength> secondConvStr;
-// translate compared target string into numeric string before match
-if ( iAlgorithm )
-{
-iAlgorithm->Converter( aFirst, firstConvStr );
-iAlgorithm->Converter( aSecond, secondConvStr );
-}
-else
-{
-firstConvStr.Copy( aFirst );
-secondConvStr.Copy( aSecond );
-}
-if( firstConvStr.Right( index + 1 ).FindC( secondConvStr.Left( index + 1 ) ) != KErrNotFound )
 {
 matchCount = index + 1;
 }
 }
 // ---------------------------------------------------------
 // Find pane text is including Chinese word
 // ---------------------------------------------------------
 //
-TBool CFindUtilChineseECE::IsChineseWord(const TDesC& aWord)
+TBool CFindUtilChineseECE::IsChineseWordIncluded(const TDesC& aWord)
 {
 TBool IsChineseSearchStr = EFalse;
 const TInt len = aWord.Length();
 for (TInt ii = 0; ii < len; ii++)
 {
-if ((TInt) aWord[ii] >= KMinUnicodeHz)
+if ( ((TUint16) aWord[ii] >= KMinUnicodeHz) &&
+((TUint16) aWord[ii] <= KMaxUnicodeHz) )
 {
 IsChineseSearchStr = ETrue;
 break;
 }
 }
 {
 const TInt len = aWord.Length();
 for (TInt index = 0; index < len; index++)
 {
-if (IsStrokeSymbol(TInt(aWord[index])) != 0)
+if (IsStrokeSymbol(TUint16(aWord[index])) != 0)
 {
 return ETrue;
 }
 }
 return EFalse;
+}
+// --------------------------------------------------------
+// Find pane text is all Chinese word(s)
+// --------------------------------------------------------
+//
+TBool CFindUtilChineseECE::IsAllChineseWord(const TDesC& aWord)
+{
+TBool isChineseWord = ETrue;
+const TInt len = aWord.Length();
+TBool InputMethodStroke = EFalse;
+if(iLanguage == ELangHongKongChinese && iCurInputMode == 0x0020)
+{
+InputMethodStroke = ETrue;
+}
+for( TInt i = 0; i < len; i++ )
+{
+if( (( TUint16 )aWord[i] > KMaxUnicodeHz ) ||  (( TUint16 )aWord[i] < KMinUnicodeHz )
+|| ( InputMethodStroke && IsStrokeSymbol(aWord[i]) ) )
+{
+isChineseWord = EFalse;
+break;
+}
+}
+return isChineseWord;
 }
 // ---------------------------------------------------------
 // Find pane text is including zhuyin symbol
 // ---------------------------------------------------------
 // ---------------------------------------------------------
 //
 TInt CFindUtilChineseECE::HandleFindRepositoryCallBack(TAny* aPtr)
 {
 TInt ret = KErrNone;
-CFindUtilChineseECE *self = static_cast<CFindUtilChineseECE*> (aPtr);
+CFindUtilChineseECE* self = static_cast<CFindUtilChineseECE*> (aPtr);
-TInt searchMode = 0;
+// Get changed key either from language repository (AknFepRepository)
-if (self->iWatcher->ChangedKey() == KAknFepInputTxtLang)
+// or from adaptive repository (AvkonRepository).
-{
+TUint32 changedKey = self->iWatcher->ChangedKey();
-TInt inputLanguage = 0;
+if ( changedKey == NCentralRepositoryConstants::KInvalidNotificationId )
-self->iRepositoryFind->Get(KAknFepInputTxtLang, inputLanguage);
+{
+changedKey = self->iWatcherAdaptive->ChangedKey();
-TInt prevCategory = self->CategoryOfLang(self->iLanguage);
+}
-TRAP(ret, self->OpenT9InterfaceL(TLanguage(inputLanguage)));
-TInt category = self->CategoryOfLang(TLanguage(inputLanguage));
+// Update the search method if input language or any search method variable
-if (prevCategory != category && category != 0)
+// changed
+if ( changedKey == KAknFepInputTxtLang ||
+changedKey == KAknAdaptiveSearchChinesePRC ||
+changedKey == KAknAdaptiveSearchChineseTW ||
+changedKey == KAknAdaptiveSearchChineseHongkong ||
+changedKey == KAknFepCangJieMode ||
+changedKey == KAknAvkonAdaptiveSearchEnabled )
+{
+TChineseSearchMethod prevSearchMethods = self->iSearchMethod;
+TRAP( ret, self->OpenL() );
+// Reconstruct cache if search method got changed
+if ( ret == KErrNone && prevSearchMethods != self->iSearchMethod )
 {
 TRAP(ret, self->iAlgorithm->ReconstructCacheDataL());
 }
 }
-// The below code is commented out because current CFindUtilChineseECE is used
-// on 3.2.3 which is not supported adaptive search. It will be easy to keep these code
-// for the further merging work (merge from FindUtil 5.0)
-#if 0
-if(self->iWatcherAdaptive->ChangedKey() == KAknAvkonAdaptiveSearchEnabled)
-{
-self->iRepositoryFindAdaptive->Get(KAknAvkonAdaptiveSearchEnabled, self->iSearchMethodAdaptive);
-}
-if (self->iWatcherAdaptive->ChangedKey() == KAknAdaptiveSearchChinesePRC)
-{
-self->iRepositoryFindAdaptive->Get(KAknAdaptiveSearchChinesePRC, searchMode);
-if(searchMode ==0)
-{
-self->iSearchMethodPRC = EAdptSearchPinyin;
-}
-else if(searchMode ==1)
-{
-self->iSearchMethodPRC = EAdptSearchStroke;
-}
-}
-if (self->iWatcherAdaptive->ChangedKey() == KAknAdaptiveSearchChineseTW )
-{
-self->iRepositoryFindAdaptive->Get(KAknAdaptiveSearchChineseTW , searchMode);
-if(searchMode ==0)
-{
-self->iSearchMethodTaiWan = EAdptSearchZhuyin;
-}
-else if(searchMode ==1)
-{
-self->iSearchMethodTaiWan = EAdptSearchStroke;
-}
-}
-if (self->iWatcherAdaptive->ChangedKey() == KAknAdaptiveSearchChineseHongkong )
-{
-self->iRepositoryFindAdaptive->Get(KAknAdaptiveSearchChineseHongkong , searchMode);
-if(searchMode ==1)
-{
-self->iRepositoryFind->Get(KAknFepCangJieMode , searchMode);
-switch (searchMode)
-{
-case 0:
-self->iSearchMethodHongKong = EAdptSearchNormalCangjie;
-break;
-case 1:
-self->iSearchMethodHongKong = EAdptSearchEasyCangjie;
-break;
-case 2:
-self->iSearchMethodHongKong = EAdptSearchAdvCangjie;
-break;
-}
-}
-else if(searchMode ==0)
-{
-self->iSearchMethodHongKong = EAdptSearchStroke;
-}
-}
-if (self->iWatcher->ChangedKey() == KAknFepCangJieMode )
-{
-self->iRepositoryFind->Get(KAknFepCangJieMode , searchMode);
-switch (searchMode)
-{
-case 0:
-self->iSearchMethodHongKong = EAdptSearchNormalCangjie;
-break;
-case 1:
-self->iSearchMethodHongKong = EAdptSearchEasyCangjie;
-break;
-case 2:
-self->iSearchMethodHongKong = EAdptSearchAdvCangjie;
-break;
-}
-}
-#endif
 return ret;
 }
 // ---------------------------------------------------------
 // Update input method in ptiengine from find pane
 {
 iCurInputMode = pState->CurrentInputMode();
 }
 }
 }
-}
-void CFindUtilChineseECE::SetKeyboardMode(TInt aMode)
-{
-iKeyboardMode = aMode;
 }
 // The below code is commented out because current CFindUtilChineseECE is used
 // on 3.2.3 which is not supported adaptive search. It will be easy to keep these code
 // for the further merging work (merge from FindUtil 5.0)
 {
 if( aNextChars->Des().Length() == aNextChars->Des().MaxLength())
 {
 aNextChars = aNextChars->ReAllocL( aNextChars->Des().MaxLength()+10 );
 }
 aNextChars->Des().Append(aCh);
 }
 }
 // ---------------------------------------------------------------------------
 // UpdateNextCharFromString
 - searchStrIndex);
 // Compare word
 if (!pStringInfo->isChinese)
 {
-searchStrIndex += MatchString(pStringInfo->segmentString,
+searchStrIndex += MatchStringL(pStringInfo->segmentString,
 transSearchBuf);
 }
 if (searchStrIndex >= searchStrLength)
 {
 }
 }
 }
 tempSpellList.ResetAndDestroy();
-if(ReverseMatchString(aCurrentBuf,temp)>0)
+if(ReverseMatchStringL(aCurrentBuf,temp)>0)
 {
 if (pStringInfo->isChinese)
 {
 if((pStringInfo->segmentString).Length()>aindexforfind+2)//in same segment
 {
 }
 //Find if search string has chinese word.
 //Compare with item string if find chinese word in item string then delete it from search and item string.
-if(IsChineseWord(tempBuf))
+if(IsChineseWordIncluded(tempBuf))
 {
 if(TrimChineseCharacterL(itemString,tempBuf,aNextChars))
 {
 spellList.ResetAndDestroy();//destroy spellList
 spellList.Close();
 indexlast = index;
 }
 }
 else
 {//english words and chinese words don't coexist in same segment
-matchLength = MatchString(bufcurrent, transSearchBuf);
+matchLength = MatchStringL(bufcurrent, transSearchBuf);
 searchStrIndex +=matchLength;
 if (searchStrIndex >= searchStrLength)
 {
 //append next char in the same segment
 ret = ETrue;
 return IsAdaptiveFindMatchL( aItemString, aSearchText, aNextChars);
 }
 #endif
-// ----------------------------------------------------------------------------
-// CFindUtilChineseECE::ConvertdDataToKeyBoardModeL
-// Converts the input data to the key board mode specified by the query
-// ----------------------------------------------------------------------------
-void CFindUtilChineseECE::ConvertdDataToKeyBoardModeL(CPsQuery& aQuery,
-const TDesC& aSearchTargetStr,
-TBuf<KMaxWordInterpretationLen>& aOutputNumInterpretationStr)
-{
-if (iKeyboardMode == EItut)
-{
-iAlgorithm->GetKeyMap()->GetNumericKeyString(aSearchTargetStr, aOutputNumInterpretationStr);
-}
-else if (iKeyboardMode == EQwerty)
-{
-aOutputNumInterpretationStr = aSearchTargetStr;
-aOutputNumInterpretationStr.LowerCase();
-}
-else
-{
-TInt len = -1;
-TBuf<KPsQueryMaxLen> outBuf;
-iAlgorithm->GetKeyMap()->GetNumericKeyString(aSearchTargetStr, outBuf);
-// Always loop thru the lowest length
-if (aSearchTargetStr.Length() > aQuery.Count() )
-{
-len = aQuery.Count();
-}
-else
-{
-len = aSearchTargetStr.Length();
-}
-// Interprete search target str according to the query char mode
-for (TInt i = 0; i < len; i++)
-{
-if (aQuery.GetItemAtL(i).Mode() == EItut)
-{
-aOutputNumInterpretationStr.Append(outBuf[i]);
-}
-else
-{
-aOutputNumInterpretationStr.Append(aSearchTargetStr[i]);
-}
-}
-aOutputNumInterpretationStr.LowerCase();
-}
-}
 void CFindUtilChineseECE::GetPartOfQueryL(CPsQuery& aSrcQuery, TInt aStartIndex,
 TInt aEndIndex, CPsQuery& aDestQuery)
 {
 TInt index = aStartIndex;
 newItem->SetCharacter(tempItem.Character());
 newItem->SetMode(tempItem.Mode());
 aDestQuery.AppendL(*newItem);
 }
 }
 else
 {
 User::Panic(KPanicReason, 0);
 }
 // remove the charator of index
 aQuery.Remove( index );
 // ajust index after remove
 index--;
 }
+break;
 default:
 continue;
 } // switch
 } // for
 }

branch	RCL_3
changeset 58	d4f567ce2e7c
parent 32	2828b4d142c0
child 64	c1e8ba0c2b16