fep/aknfep/src/AknFepZhuyinAnalyser.cpp
changeset 0 eb1f2e154e89
equal deleted inserted replaced
-1:000000000000 0:eb1f2e154e89
       
     1 /*
       
     2 * Copyright (c) 2002-2005 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:            Implementation of the vkb data manager
       
    15  *
       
    16 */
       
    17 
       
    18 
       
    19 
       
    20 
       
    21 
       
    22 
       
    23 
       
    24 
       
    25 
       
    26 
       
    27 
       
    28 
       
    29 // system includes
       
    30 
       
    31 
       
    32 // user includes
       
    33 #include "AknFepZhuyinAnalyser.h"
       
    34 #include "AknFepZhuyinAnalyserDb.h"
       
    35 
       
    36 class TSpellBand
       
    37     {
       
    38 public:
       
    39     int iStart;
       
    40     int iCount;
       
    41     };
       
    42 
       
    43 class TSpellAnalysis : public TPriQueLink
       
    44     {
       
    45 public:
       
    46     RArray<TInt> iSeparators;
       
    47     TSpellAnalysis( )
       
    48         {
       
    49         iPriority = -0x10000;
       
    50         }
       
    51     ~TSpellAnalysis( )
       
    52         {
       
    53         iSeparators.Close( );
       
    54         }
       
    55 
       
    56     TSpellAnalysis( const TSpellAnalysis& aSource )
       
    57         {
       
    58         iPriority = aSource.iPriority;
       
    59         for (TInt i = 0; i < aSource.iSeparators.Count( ); ++i )
       
    60             {
       
    61             iSeparators.Append( aSource.iSeparators[i] );
       
    62             }
       
    63         }
       
    64     void Calculate( )
       
    65         {
       
    66         iPriority = (iSeparators.Count() + 1) << 16;
       
    67         TInt multi = 12;
       
    68         for (TInt i = 0; i < iSeparators.Count(); ++i )
       
    69             {
       
    70             iPriority += ( 6 - iSeparators[i]) << multi;
       
    71             if ( multi >= 3 )
       
    72                 {
       
    73                 multi -= 3;
       
    74                 }
       
    75             }
       
    76         iPriority = -iPriority;
       
    77         }
       
    78     TInt GetStartPos( )
       
    79         {
       
    80         if ( iSeparators.Count() == 0 )
       
    81             {
       
    82             return 0;
       
    83             }
       
    84         else
       
    85             {
       
    86             return iSeparators[ iSeparators.Count() - 1 ];
       
    87             }
       
    88         }
       
    89     void AddSeparator( TInt aPos )
       
    90         {
       
    91         iSeparators.Append( aPos );
       
    92         Calculate( );
       
    93         }
       
    94     };
       
    95 
       
    96 // -----------------------------------------------------------------------------
       
    97 // CAknFepVkbPinyinAnalyser::CAknFepVkbPinyinAnalyser
       
    98 // (other items were commented in a header).
       
    99 // -----------------------------------------------------------------------------
       
   100 //
       
   101 CAknFepZhuyinAnalyser::CAknFepZhuyinAnalyser( )
       
   102     {
       
   103     iAnalysisFlag = EFalse;
       
   104     }
       
   105 
       
   106 // -----------------------------------------------------------------------------
       
   107 // CAknFepVkbPinyinAnalyser::NewL
       
   108 // (other items were commented in a header).
       
   109 // -----------------------------------------------------------------------------
       
   110 //
       
   111 CAknFepZhuyinAnalyser* CAknFepZhuyinAnalyser::NewL( CZhuyinAnalyserDbFeed* aDb )
       
   112     {
       
   113     CAknFepZhuyinAnalyser* self = new ( ELeave ) CAknFepZhuyinAnalyser();
       
   114     CleanupStack::PushL( self );
       
   115     self->ConstructL( aDb );
       
   116     CleanupStack::Pop( self );
       
   117     return self;
       
   118     }
       
   119 
       
   120 // -----------------------------------------------------------------------------
       
   121 // CAknFepVkbPinyinAnalyser::~CAknFepVkbPinyinAnalyser
       
   122 // (other items were commented in a header).
       
   123 // -----------------------------------------------------------------------------
       
   124 //
       
   125 CAknFepZhuyinAnalyser::~CAknFepZhuyinAnalyser( )
       
   126     {
       
   127     delete []iParagraph;
       
   128     delete []iSpellLibrary;
       
   129     delete iLastResult;
       
   130     delete iDb;
       
   131     }
       
   132 
       
   133 void CAknFepZhuyinAnalyser::ConstructL( CZhuyinAnalyserDbFeed* aDb )
       
   134     {
       
   135     ASSERT( aDb != NULL );
       
   136     iDb = aDb;
       
   137 
       
   138     TInt length = iDb->GetSpellCount( );
       
   139 
       
   140     iSpellLibrary = new(ELeave) TPtrC[length];
       
   141     for (TInt i = 0; i < length; ++i )
       
   142         {
       
   143         iSpellLibrary[i].Set( aDb->GetSpellByIndex( i ) );
       
   144         }
       
   145 
       
   146     TInt current = 0;
       
   147     TInt pinyinElementCount = iDb->GetSpellElementCount( );
       
   148     iParagraph = new(ELeave) TSpellBand[pinyinElementCount];
       
   149     iParagraph[current].iStart = 0;
       
   150     for (TInt i = 0; i < length; ++i )
       
   151         {
       
   152         if ( iSpellLibrary[i][0] != iDb->GetSpellElementByIndex( current ) )
       
   153             {
       
   154             iParagraph[current].iCount = i - iParagraph[current].iStart;
       
   155             current++;
       
   156             iParagraph[current].iStart = i;
       
   157             while (iSpellLibrary[i][0]
       
   158                 != iDb->GetSpellElementByIndex( current ) )
       
   159                 {
       
   160                 iParagraph[current].iCount = 0;
       
   161                 current ++;
       
   162                 iParagraph[current].iStart = i;
       
   163                 }
       
   164             }
       
   165         }
       
   166 
       
   167     iParagraph[current].iCount = length - iParagraph[current].iStart;
       
   168 
       
   169     }
       
   170 
       
   171 HBufC* CAknFepZhuyinAnalyser::LastAnalysisResult( )
       
   172     {
       
   173     return iLastResult;
       
   174     }
       
   175 
       
   176 TBool CAknFepZhuyinAnalyser::AnalyzeL( const TDesC& aInputString )
       
   177     {
       
   178     delete iLastResult;
       
   179     iLastResult = NULL;
       
   180 
       
   181     iLastResult = HBufC::NewL( aInputString.Length( ) * 2 );
       
   182 
       
   183     if ( aInputString.Length( ) < 1 )
       
   184         {
       
   185         return ETrue;
       
   186         }
       
   187 
       
   188     if ( aInputString.Length( ) == 1 )
       
   189         {
       
   190         iLastResult->Des().Append( aInputString[0] );
       
   191         if ( iDb->IsFirstElement( aInputString[0] ) )
       
   192             {
       
   193             return ETrue;
       
   194             }
       
   195         else
       
   196             {
       
   197             return EFalse;
       
   198             }
       
   199         }
       
   200 
       
   201     if ( !iDb->IsFirstElement( aInputString[0] ) )
       
   202         {
       
   203         iLastResult->Des().Append( aInputString );
       
   204         return EFalse;
       
   205         }
       
   206 
       
   207     int first = 0, second = 1;
       
   208     TBool seriateTonemark = EFalse;
       
   209     for (; second < aInputString.Length( ); first++, second++ )
       
   210         {
       
   211         if ( iDb->IsToneMark( aInputString[first], aInputString[second] ) )
       
   212             {
       
   213             iLastResult->Des().Append( aInputString );
       
   214             seriateTonemark = ETrue;
       
   215             break;
       
   216             }
       
   217         }
       
   218 
       
   219     first = 0;
       
   220     second = 1;
       
   221     int previous = 0;
       
   222     iAnalysisFlag = ETrue;
       
   223     //rough spilit
       
   224     for (; second < aInputString.Length( ) && !seriateTonemark; first++, second++ )
       
   225         {
       
   226         if ( !iDb->IsNormalElement( aInputString[first] ) )
       
   227             {
       
   228             //go to detail analysis
       
   229             if ( first > previous )
       
   230                 {
       
   231                 TPtrC toanalysis = aInputString.Mid( previous, first
       
   232                     - previous );
       
   233                 DetailAnalyseL( toanalysis );
       
   234                 }
       
   235 
       
   236             iLastResult->Des().Append( aInputString[first] );
       
   237             previous = first + 1;
       
   238             }
       
   239         else if ( !iDb->IsNormalElement( aInputString[second] ) )
       
   240             {
       
   241             //go to detail analysis
       
   242             if ( second > previous )
       
   243                 {
       
   244                 TPtrC toanalysis = aInputString.Mid( previous, second
       
   245                     - previous );
       
   246                 DetailAnalyseL( toanalysis );
       
   247                 }
       
   248 
       
   249             iLastResult->Des().Append( aInputString[second] );
       
   250             previous = second + 1;
       
   251             first ++;
       
   252             second ++;
       
   253             }
       
   254         else if ( iDb->GetSpellElementType( aInputString[first] )
       
   255             == ESpellVowel || iDb->GetSpellElementType( aInputString[second] )
       
   256             == ESpellVowel )
       
   257             {
       
   258             continue;
       
   259             }
       
   260         else if ( iDb->GetSpellElementType( aInputString[first] )
       
   261             == ESpellConsonant
       
   262             || iDb->GetSpellElementType( aInputString[second] )
       
   263                 == ESpellConsonant )
       
   264             {
       
   265             //go to detail analysis
       
   266             TPtrC toanalysis = aInputString.Mid( previous, second - previous );
       
   267             DetailAnalyseL( toanalysis );
       
   268             iLastResult->Des().Append( KProgramSeparator );
       
   269             previous = second;
       
   270             }
       
   271         else
       
   272             {
       
   273             if ( (aInputString[second] == L'h'&& ( aInputString[first] == L'z' || aInputString[first] == L'c' || aInputString[first] == L's')) || //ch, sh, zh
       
   274             (aInputString[second] == L'g' && aInputString[first] == L'n') || //ng
       
   275             (aInputString[second] == L'n' && aInputString[first] == L'h') //hn 
       
   276             )
       
   277                 {
       
   278                 }
       
   279             else
       
   280                 {
       
   281                 //go to detail analysis
       
   282                 TPtrC toanalysis = aInputString.Mid(previous, second - previous);
       
   283                 DetailAnalyseL(toanalysis);
       
   284                 iLastResult->Des().Append(KProgramSeparator);
       
   285                 previous = second;
       
   286                 }
       
   287             }
       
   288         }
       
   289 
       
   290     if( aInputString.Length() <= previous 
       
   291     		|| second> aInputString.Length() 
       
   292     		|| seriateTonemark )
       
   293         {
       
   294         return TRUE;
       
   295         }
       
   296 
       
   297     TPtrC toanalysis = aInputString.Mid(previous, second - previous);
       
   298     DetailAnalyseL(toanalysis);
       
   299     return iAnalysisFlag;
       
   300     }
       
   301 
       
   302 TBool CAknFepZhuyinAnalyser::DetailAnalyseL( const TDesC& aInputString )
       
   303     {
       
   304     TPriQue<TSpellAnalysis> open;
       
   305     TSpellAnalysis* p = new(ELeave) TSpellAnalysis();
       
   306 
       
   307     open.Add( *p );
       
   308 
       
   309     int sameLength;
       
   310     int startPos;
       
   311     TBool findRes;
       
   312     TSpellAnalysis* pNext= NULL;
       
   313 
       
   314     while ( !open.IsEmpty( ) )
       
   315         {
       
   316         pNext = open.First( );
       
   317         pNext->Deque( );
       
   318 
       
   319         startPos = pNext->GetStartPos( );
       
   320         findRes = FindSpell( aInputString.Mid( startPos ), sameLength );
       
   321 
       
   322         if ( findRes || sameLength + startPos == aInputString.Length( ) )
       
   323             {
       
   324             //got it!
       
   325             int start = 0;
       
   326             for (TInt j = 0; j < pNext->iSeparators.Count( ); ++j )
       
   327                 {
       
   328                 iLastResult->Des().Append( aInputString.Mid( start, pNext->iSeparators[j]
       
   329                     - start ) );
       
   330                 start = pNext->iSeparators[j];
       
   331                 iLastResult->Des().Append( KProgramSeparator );
       
   332                 }
       
   333 
       
   334             iLastResult->Des().Append( aInputString.Mid( start, aInputString.Length( )
       
   335                 - start ) );
       
   336             break;
       
   337             }
       
   338         else if ( sameLength == 0 )
       
   339             {
       
   340             delete pNext;
       
   341             pNext = NULL;
       
   342             }
       
   343         else
       
   344             {
       
   345             int partLength = sameLength - 1;
       
   346             while (partLength > 0 )
       
   347                 {
       
   348                 int templen;
       
   349                 if ( FindSpell( aInputString.Mid( startPos, partLength ),
       
   350                     templen ) )
       
   351                     {
       
   352                     TSpellAnalysis* q = new TSpellAnalysis(*pNext);
       
   353                     q->AddSeparator( startPos + partLength );
       
   354                     open.Add( *q );
       
   355                     }
       
   356                 partLength --;
       
   357                 }
       
   358             pNext->AddSeparator( startPos + sameLength );
       
   359             open.Add( *pNext );
       
   360             }
       
   361         }
       
   362     if ( pNext )
       
   363         {
       
   364         delete pNext;
       
   365         pNext = NULL;
       
   366         while ( !open.IsEmpty( ) )
       
   367             {
       
   368             TSpellAnalysis* p = open.First( );
       
   369             p->Deque( );
       
   370             delete p;
       
   371             }
       
   372         return true;
       
   373         }
       
   374     else
       
   375         {
       
   376         //not found
       
   377         /*
       
   378          FindSpell(aInputString, sameLength);
       
   379          int offset = 0;
       
   380          TBool rtn = sameLength > 0;
       
   381          while( sameLength > 0 )
       
   382          {
       
   383          iLastResult->Des().Append(aInputString.Mid(offset, sameLength));
       
   384          iLastResult->Des().Append(KProgramSeparator);
       
   385          offset += sameLength;
       
   386          FindSpell(aInputString.Mid(offset), sameLength);
       
   387          }
       
   388          */
       
   389         //FindSpell(aInputString, sameLength);
       
   390         int offset = 0;
       
   391 
       
   392         while (offset < aInputString.Length( ) )
       
   393             {
       
   394             FindSpell( aInputString.Mid( offset ), sameLength );
       
   395 
       
   396             if ( sameLength )
       
   397                 {
       
   398                 iLastResult->Des().Append( aInputString.Mid( offset, sameLength ) );
       
   399                 iLastResult->Des().Append( KProgramSeparator );
       
   400                 offset += sameLength;
       
   401                 }
       
   402             else
       
   403                 {
       
   404                 iLastResult->Des().Append( aInputString.Mid( offset, 1 ) );
       
   405 
       
   406                 iLastResult->Des().Append( KProgramSeparator );
       
   407 
       
   408                 offset += 1;
       
   409                 }
       
   410             }
       
   411         if ( iLastResult->Des()[ iLastResult->Length() - 1 ] == KProgramSeparator )
       
   412             {
       
   413             iLastResult->Des().SetLength( iLastResult->Length( ) - 1 );
       
   414             }
       
   415         iAnalysisFlag = EFalse;
       
   416         return EFalse;
       
   417         }
       
   418     }
       
   419 
       
   420 TBool CAknFepZhuyinAnalyser::FindSpell( const TDesC& aSpell, TInt& aSameLength )
       
   421     {
       
   422     int index = aSpell[0] - iDb->GetSpellElementByIndex( 0 );
       
   423 
       
   424     int start = iParagraph[index].iStart;
       
   425     int end = iParagraph[index].iCount + iParagraph[index].iStart - 1;
       
   426     int mid = (start + end ) >> 1;
       
   427     int result = 0;
       
   428     aSameLength = 0;
       
   429     while (mid > start && mid < end )
       
   430         {
       
   431         result = Compare( iSpellLibrary[mid], aSpell, aSameLength );
       
   432         if ( result == 0 )
       
   433             {
       
   434             return true;
       
   435             }
       
   436         else if ( result < 0 )
       
   437             {
       
   438             start = mid;
       
   439             mid = (start + end ) >> 1;
       
   440             }
       
   441         else
       
   442             {
       
   443             end = mid;
       
   444             mid = (start + end) >> 1;
       
   445             }
       
   446         }
       
   447     int newLength;
       
   448     if ( result > 0 )
       
   449         {
       
   450         result = Compare( iSpellLibrary[start], aSpell, newLength );
       
   451         }
       
   452     else
       
   453         {
       
   454         result = Compare( iSpellLibrary[end], aSpell, newLength );
       
   455         }
       
   456     newLength > aSameLength ? aSameLength = newLength : aSameLength;
       
   457 
       
   458     return result == 0;
       
   459     }
       
   460 
       
   461 TInt CAknFepZhuyinAnalyser::Compare( const TDesC& aFirst,
       
   462     const TDesC& aSecond, TInt& aSameLength )
       
   463     {
       
   464     aSameLength = 0;
       
   465 
       
   466     TInt length = aFirst.Length( ) > aSecond.Length( ) ? aSecond.Length( )
       
   467         : aFirst.Length( );
       
   468 
       
   469     for (TInt i = 0; i < length; ++i )
       
   470         {
       
   471         if ( aFirst[i] != aSecond[i] )
       
   472             {
       
   473             return aFirst[i] - aSecond[i];
       
   474             }
       
   475 
       
   476         aSameLength ++;
       
   477         }
       
   478 
       
   479     return aFirst.Length( ) - aSecond.Length( );
       
   480     }
       
   481