/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

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

* which accompanies this distribution, and is available

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

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:         Korean Find Utilities implementation.

*

*/

#include "FindUtilKorean.h"

const TInt KSBase = 0xac00; // base address for hangul syllables

const TInt KLBase = 0x1100; // base address for L-jamo

const TInt KVBase = 0x1161; // base address for V-jamo

const TInt KTBase = 0x11a7; // base address for T-jamo

const TInt KCBase = 0x3131; // base address for hangul compatibility jamo

const TInt KLCount = 19; // count of L-jamos

const TInt KVCount = 21; // count of V-jamos

const TInt KTCount = 28; // count of T-jamos

const TInt KNCount = KVCount * KTCount; // count of V&T-jamo combinations

const TInt KSCount = KLCount * KNCount; // total count of hangul syllables

const TInt KMaxLengthDecomposedSyllable = 3; // syllable can contain 3 jamos

const TInt KLitTab('\t'); // word separator: <tab>

const TInt KLitSpace(' '); // word separator: <space>

const TInt KLitHyphen('-'); // word separator: <hyphen>

const TInt KLitStar('*'); // wildcard matching: <star>

const TInt KLitQuestion('?'); // wildcard matching <question>

// Conversion table for hangul compatibility jamo

const TUint16 conversionTableFromCompatibilityJamoToJamo[] = {

0x1100,

0x1101,

0x11AA,

0x1102,

0x11AC,

0x11AD,

0x1103,

0x1104,

0x1105,

0x11B0,

0x11B1,

0x11B2,

0x11B3,

0x11B4,

0x11B5,

0x11B6,

0x1106,

0x1107,

0x1108,

0x11B9,

0x1109,

0x110A,

0x110B,

0x110C,

0x110D,

0x110E,

0x110F,

0x1110,

0x1111,

0x1112,

0x1161,

0x1162,

0x1163,

0x1164,

0x1165,

0x1166,

0x1167,

0x1168,

0x1169,

0x116A,

0x116B,

0x116C,

0x116D,

0x116E,

0x116F,

0x1170,

0x1171,

0x1172,

0x1173,

0x1174,

0x1175,

};

#define KCCount (sizeof(conversionTableFromCompatibilityJamoToJamo) / sizeof(TUint16))

// ============================ MEMBER FUNCTIONS =============================

// ---------------------------------------------------------------------------

// Symbian constructor

// ---------------------------------------------------------------------------

//

CFindUtilKorean* CFindUtilKorean::NewL()

    {

    CFindUtilKorean* self = new ( ELeave ) CFindUtilKorean();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// ---------------------------------------------------------------------------

// Symbian second-phase constructor

// ---------------------------------------------------------------------------

//

void CFindUtilKorean::ConstructL()

    {

    }

// ---------------------------------------------------------------------------

// Default constructor

// ---------------------------------------------------------------------------

//

CFindUtilKorean::CFindUtilKorean()

    {

    }

// ---------------------------------------------------------------------------

// Destructor

// ---------------------------------------------------------------------------

//

CFindUtilKorean::~CFindUtilKorean()

    {

    }

// ---------------------------------------------------------------------------

// Checks that is given character korean language or not.

// ---------------------------------------------------------------------------

//

TBool CFindUtilKorean::IsKoreanLanguage( const TDesC& aDes )

    {

    for ( TInt i = 0; i < aDes.Length(); i++ )

    	{

    	if ( IsHangulSyllable( aDes[ i ] ) || IsHangulCompatibilityJamo( aDes[ i ] ) )

    		{

    		return ETrue;

    		}

    	}

    return EFalse;

    }

// ---------------------------------------------------------------------------

// Compares two strings against others.

// ---------------------------------------------------------------------------

//

TBool CFindUtilKorean::IsFindMatchL( 

    const TDesC& aItemString, 

    const TDesC& aSearchText )

    {

    TBool result( EFalse );

    // To disable the wildchar matching provided by MatchC.

    if ( KErrNotFound != aSearchText.Locate( KLitQuestion ) && 

        KErrNotFound != aSearchText.Locate( KLitStar ) )

    	{

    	return EFalse;

    	}

    // Convert aItemString to single jamo's.

    HBufC* itemString = HBufC::NewLC( aItemString.Length() * KMaxLengthDecomposedSyllable );

    DecomposeToPlainJamos( aItemString, itemString );

    HBufC* searchText = HBufC::NewLC( aSearchText.Length() * KMaxLengthDecomposedSyllable + 2 );

    searchText->Des().Append( KLitStar );

    // Convert aSearchText to single jamo's.

    DecomposeToPlainJamos( aSearchText, searchText );

    searchText->Des().Append( KLitStar );

    // Compare strings containing plain jamo's against others.

    for ( TInt i = 0; i < itemString->Length() && !result; i++ )

        {

        if ( 0 == i || IsFindWordSeparator( 

            static_cast<TChar>( itemString->Des()[ i - 1 ] ) ) )

            {

            if ( KErrNotFound != itemString->Mid( i ).MatchC( *searchText ) )

                {

                result = ETrue; // match found

                }

            }

        }

    CleanupStack::PopAndDestroy( searchText );

    CleanupStack::PopAndDestroy( itemString );

    return result;    

    }

// ---------------------------------------------------------------------------

// Decomposes given string to plain jamos.

// ---------------------------------------------------------------------------

//

void CFindUtilKorean::DecomposeToPlainJamos( 

    const TDesC& aString,

    HBufC* aDecomposedString )

    {

    // Go thought all characters and decompose if needed.

    for ( TInt i = 0; i < aString.Length(); i++ )

        {

        // If character is 'hangul syllable', decompose it to single jamos.

        if ( IsHangulSyllable( aString[ i ] ) )

            {

            TBuf<KMaxLengthDecomposedSyllable> buf ( KNullDesC );

            Decompose( aString[ i ], buf );

            aDecomposedString->Des().Append( buf );

            }

        else if ( IsHangulCompatibilityJamo( aString[ i ] ) )

	        {

	        TUint16 jamo = conversionTableFromCompatibilityJamoToJamo[ aString[i] - KCBase ];

	        aDecomposedString->Des().Append( jamo );	

	        }

        // Otherwise append character directly to 'decomposed string'.

        else

            {

            aDecomposedString->Des().Append( aString[ i ] );

            }

        }

    }

// ---------------------------------------------------------------------------

// Decomposes hangul syllables to single jamos.

// ---------------------------------------------------------------------------

//

void CFindUtilKorean::Decompose( TChar aChar, TDes& aDecomposedString )

    {

    // Calculate single jamo's.

    TInt index = static_cast<TInt> ( aChar ) - KSBase;

    TInt l = KLBase + index / KNCount;

    TInt v = KVBase + ( index % KNCount ) / KTCount;

    TInt t = KTBase + index % KTCount;

    // Append single jamo's to 'decomposed string'.

    aDecomposedString.Append( static_cast<TChar> ( l ) );

    aDecomposedString.Append( static_cast<TChar> ( v ) );

    if ( t != KTBase )

        {

        aDecomposedString.Append( static_cast<TChar> ( t ) );

        }

    }

// ---------------------------------------------------------------------------

// Checks that is given character hangul syllable or not.

// ---------------------------------------------------------------------------

//

TBool CFindUtilKorean::IsHangulSyllable( TChar aChar )

    {

    // Character is 'hangul syllable' 

    // if it's numeric value is between KSBase and KSBase + KSCount.

    TInt index = static_cast<TInt> ( aChar ) - KSBase;

    if ( index < 0 || index >= KSCount )

        {

        return EFalse;

        }

    return ETrue;

    }

// ---------------------------------------------------------------------------

// Checks that is given character word separator or not.

// ---------------------------------------------------------------------------

//

TBool CFindUtilKorean::IsFindWordSeparator( TChar aChar )

    {

    return aChar == KLitSpace || aChar == KLitHyphen || aChar == KLitTab;

    }

// ---------------------------------------------------------------------------

// Checks that is given character hangul syllable or not.

// ---------------------------------------------------------------------------

//

TBool CFindUtilKorean::IsHangulCompatibilityJamo( TChar aChar )

    {

    // Character is 'hangul compatibility jamo' 

    // if it's numeric value is between KCBase and KCBase + KCCount.

    TInt index = static_cast<TInt> ( aChar ) - KCBase;

    if ( index < 0 || index >= KCCount )

        {

        return EFalse;

        }

    return ETrue;

    }

// ---------------------------------------------------------------------------

// It tests a matching.

// ---------------------------------------------------------------------------

//

TBool CFindUtilKorean::Match( const TDesC& aContactsField, const TDesC& aWord )

    {

    TBool retVal = EFalse;

    // Match does not occur if string where search is made,

    // does not contain any characters.

    if ( aContactsField.Length() )

        {

       // In case that both of strings contain some characters,

       // matching is made with function below.

      TRAPD(err, retVal = IsFindMatchL( aContactsField, aWord ));

      if (err != KErrNone)

    	{

    	retVal = EFalse;

    	}

        }

   return retVal;

    }

// ---------------------------------------------------------------------------

// It tests a partial matching.

// ---------------------------------------------------------------------------

//

TBool CFindUtilKorean::MatchRefineL( 

    const TDesC& aItemString, 

    const TDesC& aSearchText )

    {

    // Match does not occur if string where search is made,

    // does not contain any characters.

    if ( aItemString.Length() == 0 )

        {

        return EFalse;

        }

    // Match occurs if string to be used in searching, 

    // does not contain any characters.

    if ( aSearchText.Length() == 0 )

        {

        return ETrue;

        }

    // In case that both of strings contain some characters,

    // matching is made with function below.

    return IsFindMatchL( aItemString, aSearchText );

    }

// -----------------------------------------------------------------------------

// CFindUtilKorean::MatchAdaptiveRefineL

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//  

TBool CFindUtilKorean::MatchAdaptiveRefineL( const TDesC& /*aItemString*/, 

	const TDesC& /*aSearchText*/, HBufC*& /*aNextChars*/ )

	{

	return 0;	

	}

// ---------------------------------------------------------------------------

// It checks whether aWord is valid.

// ---------------------------------------------------------------------------

//

TBool CFindUtilKorean::IsWordValidForMatching( const TDesC& /*aWord*/ )

    {

    return ETrue;

    }

// End of file