1 /*

     2 * Copyright (c) 2006-2007 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Identifies a contact in cache pools

    15 *

    16 */

    17 

    18 #ifndef __FINDUTILCHINESE_ECE__

    19 #define __FINDUTILCHINESE_ECE__

    20 

    21 // INCLUDES

    22 #include <e32base.h>

    23 

    24 // FORWARD DECLARATION

    25 class CPtiEngine;

    26 class CPcsAlgorithm2;

    27 class CFindRepositoryWatcher;

    28 class CRepository;

    29 class CPsQuery;

    30 

    31 // CONSTANTS

    32 const TInt KMaxWordLength = 128;

    33 const TInt KMaxWordInterpretationLen = 255;

    34 /**

    35 

    36 Defines flags that can be used to indicate what is the default search method for each language.

    37 */

    38 

    39 enum TDefaultAdaptiveSearchMethod

    40     {

    41     EAdptSearchPinyin =0,

    42     EAdptSearchStroke,

    43     EAdptSearchZhuyin,

    44     EAdptSearchNormalCangjie,

    45     EAdptSearchEasyCangjie,

    46     EAdptSearchAdvCangjie

    47     };

    48 /**

    49  *  STRINGINFO struct

    50  *

    51  *  This data struct is for splited taxt in find pane. 

    52  *  It includes two type word, which is Chinese or no-Chinese 

    53  *

    54  *  @lib FindUtil.dll

    55  *  @since S60 v3.2

    56  */

    57 struct STRINGINFO

    58     {

    59     TBuf<KMaxWordLength> segmentString;

    60     TBool isChinese;

    61     };

    62 

    63 /**

    64  *  CFindUtilChineseECE utils class

    65  *

    66  *  This class is Chinese find utils class. It handle Chinese variant find

    67  *  in PhoneBook, LandMark, Clock and so on.

    68  *

    69  *  @lib FindUtil.dll

    70  *  @since S60 v3.2

    71  */

    72 class CFindUtilChineseECE : public CBase

    73     {

    74 public:

    75 

    76     /**

    77      * Match arithmetic for general search

    78      *

    79      * @since S60 v3.2

    80      * @param aContactsField Reference to the searching target

    81      * @param aWord Reference to text in find pane

    82      * @return ETrue for the text are matched; otherwise EFalse

    83      */

    84     virtual TBool Match(const TDesC& aContactsField, const TDesC& aWord);

    85 

    86     /**

    87      * Match arithmetic for accurate search 

    88      *

    89      * @since S60 v3.2

    90      * @param aItemString Reference to the searching target

    91      * @param aWord Reference to text in find pane

    92      * @return ETrue for the text are matched; otherwise EFalse

    93      */

    94     virtual TBool MatchRefineL(const TDesC& aItemString, CPsQuery& aPsQuery);

    95 

    96     /**

    97      * Current input text is handled by this model 

    98      *

    99      * @since S60 v3.2

   100      * @param aWord Reference to text in find pane

   101      * @return ETrue for handling by this model; otherwise EFalse

   102      */

   103     virtual TBool IsWordValidForMatching(const TDesC& aWord);

   104 

   105     // The below code is commented out because current CFindUtilChineseECE is used

   106     // on 3.2.3 which is not supported adaptive search. It will be easy to keep these code 

   107     // for the further merging work (merge from FindUtil 5.0)

   108 #if 0

   109         /**

   110          * From MFindUtil It tests a partial matching.

   111          * @since 5.0

   112          * @param aItemString is a field string

   113          * @param aSearchText is a search string

   114          * @param aNextChars is a reference to buffer where next possible characters are saved. 

   115          *        The HBufC buffer may be re-allocated by this method. 

   116          *        In that case the pointer reference is modified to point to the re-allocated object.                              

   117          * @return If aSearchText has been found in aItemString, 

   118          *         ETrue is returned.

   119          */

   120         TBool MatchAdaptiveRefineL( const TDesC& aItemString, 

   121         							const TDesC& aSearchText, 

   122         							HBufC*& aNextChars);

   123 #endif

   124         

   125     /**

   126      * Create ptiengine and initialize member data 

   127      *

   128      * @since S60 v3.2

   129      * @return none

   130      */

   131     virtual void OpenL();

   132 

   133     /**

   134      * From CFindUtilBase

   135      * Close ptiEngine 

   136      *

   137      * @since S60 v3.2

   138      * @return none

   139      */

   140     virtual void Close();

   141 

   142     /**

   143      * Symbian constructor

   144      *

   145      * @since S60 v3.2

   146      * @return Pointer to created CFindUtilChineseECE object

   147      */

   148     static CFindUtilChineseECE* NewL(CPcsAlgorithm2* aAlgorithm);

   149 

   150   

   151 

   152 public:

   153 

   154     /**

   155      * C++ default constructor

   156      *

   157      * @since S60 v3.2

   158      * @return None

   159      */

   160     CFindUtilChineseECE();

   161 

   162     /**

   163      * Destructor

   164      *

   165      * @since S60 v3.2

   166      * @return None

   167      */

   168     ~CFindUtilChineseECE();

   169 

   170 public:

   171 

   172     /**

   173      * Do translate for Chinese word

   174      *

   175      * @since S60 v3.2

   176      * @param aHZUnicode For translate word

   177      * @param aSpellList Reference to spelling list for polyphonic word

   178      * @return ETrue for it can be translated; otherwise EFalse

   179      */

   180     TBool T9ChineseTranslationL(TInt16 aHZUnicode, RPointerArray<HBufC>& aSpellList);

   181 

   182     /**

   183      * Find pane text is including Chinese word

   184      *

   185      * @since S60 v3.2

   186      * @param aWord Reference to text for analyse

   187      * @return ETrue it includes Chinese; otherwise EFalse

   188      */

   189     TBool IsChineseWord(const TDesC& aWord);

   190 

   191     /*

   192      * 

   193      */

   194     void SetKeyboardMode(TInt aMode);

   195 

   196     /*

   197      * 

   198      */

   199     inline TLanguage CurrentInputLanguage()

   200         {

   201         return iLanguage;

   202         }

   203 

   204 private:

   205 

   206     /**

   207      * Symbian second-phase constructor

   208      *

   209      * @since S60 v3.2

   210      * @return None

   211      */

   212     void ConstructL(CPcsAlgorithm2* aAlgorithm);

   213 

   214     /**

   215      * Open ptiengine and active it by input language

   216      *

   217      * @since S60 v3.2

   218      * @param aLanguage Actived language

   219      * @return ETrue for opening ptiengine successfully; otherwise EFalse

   220      */

   221     TBool OpenT9InterfaceL(TLanguage aLanguage);

   222 

   223     /**

   224      * Close ptiengine

   225      *

   226      * @since S60 v3.2

   227      * @return none

   228      */

   229     void CloseT9InterfaceL();

   230 

   231     TInt CategoryOfLang(TLanguage aLanguage);

   232 

   233     /**

   234      * Translate Chinese word to its spelling

   235      *

   236      * @since S60 v3.2

   237      * @param aHZUnicode For translate word

   238      * @param aSpellList Reference to spelling list for polyphonic word

   239      * @return ETrue for this word can be translated; otherwise EFalse

   240      */

   241     TBool DoTranslationL(TInt16 aHZUnicode, RPointerArray<HBufC>& aSpellList);

   242 

   243     /**

   244      * This letter is stroke symbol

   245      *

   246      * @since S60 v3.2

   247      * @param aFindWord For analyse

   248      * @return ETrue for it is stroke symbol; otherwise EFalse

   249      */

   250     TInt IsStrokeSymbol(const TInt aFindWord);

   251     

   252     // The below code is commented out because current CFindUtilChineseECE is used

   253     // on 3.2.3 which is not supported adaptive search. It will be easy to keep these code 

   254     // for the further merging work (merge from FindUtil 5.0)

   255 #if 0

   256     /**

   257      * Do translate for Chinese word

   258      *

   259      * @since S60 v5.0.1

   260      * @param aHZUnicode For translate word

   261      * @param aSpellList Reference to spelling list for polyphonic word

   262      * @return ETrue for it can be translated; otherwise EFalse

   263      */

   264     TBool T9ChineseTranslationAdaptiveL(TInt16 aHZUnicode, RPointerArray<HBufC>& aSpellList);

   265 #endif

   266     

   267     /**

   268      * Find pane text is including separator

   269      *

   270      * @since S60 v3.2

   271      * @param aCh Analyze word

   272      * @return ETrue it is separator; otherwise EFalse

   273      */

   274     TBool IsFindWordSeparator(TChar aCh);

   275 

   276     /**

   277      * Find pane text is including stroke symbol

   278      *

   279      * @since S60 v3.2

   280      * @param aWord Reference to text for analyse

   281      * @return ETrue it is stroke symbol; otherwise EFalse

   282      */

   283     TBool IsStrokeSymbolInString(const TDesC& aWord);

   284 

   285     /**

   286      * Find pane text is including zhuyin symbol

   287      *

   288      * @since S60 v3.2

   289      * @param aWord Reference to text for analyse

   290      * @return ETrue it includes zhuyin symbol; otherwise EFalse

   291      */

   292     TBool IsZhuyinSymbolInString(const TDesC& aWord);

   293 

   294     /**

   295      * This language is support by this model

   296      *

   297      * @since S60 v3.2

   298      * @param aLang Language for support

   299      * @return ETrue it supports; otherwise EFalse

   300      */

   301     TBool IsSupportLanguage(TLanguage aLang);

   302 

   303     /**

   304      * Callback method to notify client about language change.

   305      *

   306      * @since S60 v3.2

   307      * @param aPtr Pointer to the callback data

   308      * @return Error code

   309      */

   310     static TInt HandleFindRepositoryCallBack(TAny* aPtr);

   311 

   312     /**

   313      * Splite the input text to sgement by language

   314      *

   315      * @since S60 v3.2

   316      * @param aStringInfoArr Reference to segment list

   317      * @param aItemString Reference to input text

   318      * @return none

   319      */

   320     void SplitItemStringL(RPointerArray<STRINGINFO>& aStringInfoArr, const TDesC &aItemString);

   321 

   322     /**

   323      * Insert segment to list

   324      *

   325      * @since S60 v3.2

   326      * @param aStringInfoArr Reference to segment list

   327      * @param aSegmentStr Reference to segment text

   328      * @param aChinese The segment is Chinese

   329      * @return none

   330      */

   331     void InsertStrInforArrayL(RPointerArray<STRINGINFO>& aStringInfoArr,

   332                               TDes &aSegmentStr, const TBool aChinese);

   333 

   334     /**

   335      * This segment is matched by search text

   336      *

   337      * @since S60 v3.2

   338      * @param aStringInfoArr Reference to segment list

   339      * @param aSearchText Reference to searching text

   340      * @return ETrue it is matched; otherwise EFalse

   341      */

   342     TBool MatchSegmentL(RPointerArray<STRINGINFO>& aStringInfoArr, CPsQuery& aQuery);

   343 

   344     /**

   345      * Search text by reverse

   346      *

   347      * @since S60 v3.2

   348      * @param aFirst Reference to matched text

   349      * @param aSecond Reference to matched text

   350      * @return Matched count

   351      */

   352     TInt ReverseMatchString(const TDesC& aFirst, const TDesC& aSecond);

   353 

   354     /**

   355      * Search text in other text 

   356      *

   357      * @since S60 v3.2

   358      * @param aFirst Reference to matched text

   359      * @param aSecond Reference to matched text

   360      * @return Matched count

   361      */

   362     TInt MatchString(const TDesC& aFirst, const TDesC& aSecond);

   363     

   364     /**

   365      * Search text in other text 

   366      *

   367      * @since S60 v3.2

   368      * @param aSearhTargetStr Reference to the target text to be queried

   369      * @param CPsQuery maintain the matched text from user 

   370      * @return Matched count

   371      */

   372     TInt MatchString(const TDesC& aSearhTargetStr, CPsQuery& aQuery);

   373 

   374     /**

   375      * Search Chinese word in input text 

   376      *

   377      * @since S60 v3.2

   378      * @param aFirst Reference to matched text

   379      * @param aSecond Reference to matched text

   380      * @return Matched count

   381      */

   382     TInt MatchChineseStringL(const TDesC& aSearchTargetString, CPsQuery& aQuery, TInt& aIndex);

   383 

   384     /**

   385      * Initial character search 

   386      *

   387      * @since S60 v3.2

   388      * @param aStringInfoArr Reference to spelling list

   389      * @param aSearchStr Reference to search text

   390      * @return ETrue it is matched; otherwise EFalse

   391      */

   392     TBool MatchChineseInitialStringL(RPointerArray<STRINGINFO>& aStringInfoArr,

   393                                      const TDesC& aSearchStr);

   394 

   395     /**

   396      * Maximal matched count in spelling list  

   397      *

   398      * @since S60 v3.2

   399      * @param spellList Reference to spelling list

   400      * @param aSearchStr Reference to search text

   401      * @param aPreviouStr Reference to previous matched word

   402      * @param aMatchIndex Reference to match index in Search text

   403      * @param aFullMatched Previous word is fully matched

   404      * @param aMatchedCount Previous word matched count

   405      * @param aAgain Search again

   406      * @return Matched count

   407      */

   408     TInt MaxMatchInList(RPointerArray<HBufC> &spellList, CPsQuery& aQuery,

   409                         TDesC& aPreviouStr, TInt& aMatchIndex, const TBool aFullMatched,

   410                         const TInt aMatchedCount, TBool& aAgain);

   411 

   412     /**

   413      * Search the taxt is include the input text 

   414      *

   415      * @since S60 v3.2

   416      * @param aFirst Reference to matched text

   417      * @param aSecond Reference to matched text

   418      * @return Matched count

   419      */

   420     TBool IncludeString(const TDesC& aFirst, const TDesC& aSecond);

   421 

   422     /**

   423      * Update input method in ptiengine from find pane

   424      *

   425      * @since S60 v3.2

   426      * @return none

   427      */

   428     void UpdateCurrentInputMode();

   429 

   430     /**

   431      * Remove separator from search text

   432      *

   433      * @since S60 v3.2

   434      * @param aSearchText Reference to search text

   435      * @return none

   436      */

   437     void RemoveSeparator(TDes& aSearchText);

   438     

   439     // The below code is commented out because current CFindUtilChineseECE is used

   440     // on 3.2.3 which is not supported adaptive search. It will be easy to keep these code 

   441     // for the further merging work (merge from FindUtil 5.0)

   442 #if 0

   443      /**

   444      * From MFindUtil It return next char.

   445      * @since 5.0

   446      * @param aNextChars is a buffer where next possible characters are saved

   447      * @param aCh is a char need to be input to aNextChars

   448      * 

   449      */

   450     void UpdateNextCharsL(HBufC*& aNextChars, TChar aCh);

   451      /**

   452      * From MFindUtil It return next chars.

   453      * @since 5.0

   454      * @param aNextChars is a buffer where next possible characters are saved

   455      * @param aItemString is a Contact field string

   456      */

   457     void UpdateNextCharsFromStringL(HBufC*& aNextChars, const TDesC& aItemString);   

   458     

   459      /**

   460      * From MFindUtil It return next chars.

   461      * @since 5.0

   462      * @param aNextChars is a buffer where next possible characters are saved

   463      * @param aItemString is a Contact field string

   464      * @param aSearchText Reference to search text

   465      * @param aInputLang for the input language 

   466      */

   467     TBool IsAdaptiveFindMatchL( const TDesC& aItemString, const TDesC& aSearchText,

   468                                HBufC*& aNextChars);

   469                                

   470     

   471     /**

   472     * Trim chinese charater if it is exist in search text

   473     * @since 5.0

   474     * @Param aItemString is a contact field string

   475     * @param aSearchText is a search  text   

   476     * @param aNextChars is a buffer to store the charcaters needed to display.    

   477     */ 

   478     TBool TrimChineseCharacterL(TDes& aItemString, TDes& aSearchText,HBufC*& aNextChars);

   479 

   480     /**

   481        * Trim chinese charater if it is exist in search text

   482        * @since 5.0

   483        * @Param aarray is a contact field string which had to segments

   484        * @param aSearchText is a search  text

   485        * @param aNextChars is a buffer to store the charcaters needed to display.    

   486        */ 

   487     TBool CheckEnglishFirstL( RPointerArray<STRINGINFO>& aarray, TDes& aSearchText,HBufC*& aNextChars);

   488     

   489     /**

   490      * Trim chinese charater if it is exist in search text

   491      * @since 5.0

   492      * @Param AstringInfoArr is a contact field string which had to segments

   493      * @param aindex is the current find cursor

   494      * @param aNextChars is a buffer to store the charcaters needed to display.    

   495      */ 

   496     void AppendCharInNextSegmentL(const RPointerArray<STRINGINFO>& astringInfoArr ,

   497             const TInt aindex,HBufC*& aNextChars);

   498     

   499     /**

   500      * Trim chinese charater if it is exist in search text

   501      * @since 5.0

   502      * @Param AstringInfoArr is a contact field string which had to segments

   503      * @param aindex is the current find cursor

   504      * @paran aindexforfind is the temp cursor for find

   505      * @param aCurrentBuf the data in this segment

   506      * @param aTranSearchBuf is the left search data

   507      * @param aNextChars is a buffer to store the charcaters needed to display.    

   508      */ 

   509     

   510     TBool AppendNextSegmentFirstCharL(const RPointerArray<STRINGINFO>& astringInfoArr ,

   511             const TInt aindex ,const TInt aindexforfind ,

   512             const TDes& aCurrentBuf ,const TDes& aTranSearchBuf ,

   513             HBufC*& aNextChars);

   514     

   515     /**

   516          * Check and add next char if existed overlap problem (tang ang)

   517          * @since 5.0

   518          * @Param AstringInfoArr is a contact field string which had to segments

   519          * @param aindex is the current find cursor

   520          * @paran aindexforfind is the temp cursor for find

   521          * @param aCurrentBuf is the search string

   522          * @param aNextChars is a buffer to store the charcaters needed to display.    

   523          */ 

   524     void AddNextIfOverlapL(const RPointerArray<STRINGINFO>& astringInfoArr ,

   525                 const TInt aindex,const TInt aindexforfind ,

   526                 const TDes& aCurrentBuf,HBufC*& aNextChars );

   527 #endif

   528 

   529     /**

   530      * Converts the input data to the key board mode specified by the query.

   531      * Mode is referred in the CPsQuery.

   532      * If the mode is ITU-T, data is converted to numeric.

   533      * If the mode is Qwerty, data is retained as is.

   534      * If the mode is Mix, data is conerted according to the keyboard mode 

   535      * of the corresponding query chararter 

   536      */

   537     void ConvertdDataToKeyBoardModeL(CPsQuery& aQuery, 

   538                                      const TDesC& aSearchTargetStr,

   539                                      TBuf<KMaxWordInterpretationLen>& aOutputNumInterpretationStr);

   540     

   541     // help function for using CPsQuery

   542 public:

   543     void GetPartOfQueryL(CPsQuery& aSrcQuery, TInt aStartIndex, 

   544                          TInt aEndIndex, CPsQuery& aDestQuery);

   545 private:

   546     void RemoveSeparatorL(CPsQuery& aQuery);

   547     

   548 

   549 private:

   550 

   551     /**

   552      * Ptiengine for Chinese translation (Own)

   553      */

   554     CPtiEngine* iPtiEngine;

   555 

   556     /**

   557      * Ptiengine for Chinese translation in English language (Own)

   558      */

   559     CPtiEngine* iPtiEnginePrc;

   560 

   561     /**

   562      * Current text input language 

   563      */

   564     TLanguage iLanguage;

   565 

   566     /**

   567      * It is support Chinese Language

   568      */

   569     TBool iSupportPRCChinese;

   570 

   571     /**

   572      * Current input mode

   573      */

   574     TInt iCurInputMode;

   575 

   576     /**

   577      * Repository for input mode (Own)

   578      */

   579     CRepository* iRepositoryFind;

   580 

   581     /**

   582      * The repository watcher(Own);

   583      */

   584     CFindRepositoryWatcher* iWatcher;

   585    

   586     // The below code is commented out because current CFindUtilChineseECE is used

   587     // on 3.2.3 which is not supported adaptive search. It will be easy to keep these code 

   588     // for the further merging work (merge from FindUtil 5.0)

   589 #if 0

   590     /**

   591      * Repository for input mode (Own)

   592      */     

   593     CRepository* iRepositoryFindAdaptive;	 

   594 

   595     /**

   596      * The repository watcher(Own);

   597      */

   598     CFindRepositoryWatcher* iWatcherAdaptive;

   599     

   600    

   601     /**

   602      * The default adaptive search method;

   603      */

   604     TDefaultAdaptiveSearchMethod iSearchMethodPRC;

   605     

   606     /**

   607      * The default adaptive search method;

   608      */

   609     TDefaultAdaptiveSearchMethod iSearchMethodTaiWan;

   610     

   611     /**

   612      * The default adaptive search method;

   613      */

   614     TDefaultAdaptiveSearchMethod iSearchMethodHongKong;

   615     

   616     /**

   617      * The search method;

   618      */

   619     TBool iSearchMethodAdaptive;

   620 #endif

   621 

   622     CPcsAlgorithm2* iAlgorithm;

   623 

   624     /*

   625      * The keyboard Mode

   626      */

   627     TInt iKeyboardMode;

   628 

   629     };

   630 

   631 #endif // __FINDUTILCHINESE_ECE__

   632 // End of File