/*

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

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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: 

*     A utility for providing Japanese Language-specific (UNICODE) functions.

*

*

*/

// INCLUDES FILES

#include "jplangutil.h"

#include "jplangutil.tables.h"

// LOCAL DEFINES

// LOCAL CONSTANTS AND ENUMS

#if defined(_DEBUG)

_LIT( KJPLangUtilPanic, "JPLangUtil" );

enum TJPLangUtilPanicCodes

    {

    EErrNotKatakana = 0x777,

    EErrNotVoicedKatakana

    };

#endif

enum TConvDirection

    {

    EHalfToFullWidth,

    EFullToHalfWidth

    };

const TInt KHalfWidthKatakanaRange = 59;

const TInt KHalfWidthIndex = 0;

const TInt KFullWidthIndex = 1;

const TInt KFullWidthVoicableKatakanaRange = 23;

const TInt KFullWidthSemiVoicableKatakanaRange = 5;

const TInt KHalfWidthSpecialCharRange = 21;

const TText KHalfWidthKatakanaVoicedSoundMark     = 0xff9e;

const TText KHalfWidthKatakanaSemiVoicedSoundMark = 0xff9f;

// The following Full-width (semi-)voiced markers are

// *also* considered Hiragana, per Unicode spec.

const TText KFullWidthKatakanaVoicedSoundMark     = 0x309b;

const TText KFullWidthKatakanaSemiVoicedSoundMark = 0x309c;

const TText KHalfWidthKatakanaLowerBound = 0xff65;

const TText KHalfWidthKatakanaUpperBound = 0xff9f;

const TText KFullWidthKatakanaLowerBound = 0x30a0;

const TText KFullWidthKatakanaUpperBound = 0x30ff;

const TText KCJKUnifiedIdiographLowerBound = 0x4e00;

const TText KCJKUnifiedIdiographUpperBound = 0x9fa5;

const TText KCJKUnifiedIdeographExtALowerBound = 0x3400;

const TText KCJKUnifiedIdeographExtAUpperBound = 0x4dbf;

const TText KHalfToFullWidthASCIIOffset = 0xfee0;

const TText KHalfWidthASCIILowerBound = 0x0021; // Leaves out space (0x0020)

const TText KHalfWidthASCIIUpperBound = 0x007e;

const TText KFullWidthASCIILowerBound = 0xff01;

const TText KFullWidthASCIIUpperBound = 0xff5e;

const TUint KFullWidthHiraganaSmallA = 0x3041;

const TUint KFullWidthHiraganaVU = 0x3094;

const TUint KFullWidthHiraganaU = 0x3046;

const TUint KFullWidthHiraganaVoicedSound = 0x309B;

const TUint KFullWidthKatakanaSmallA = 0x30a1;

const TUint KFullWidthKatakanaSmallVU = 0x30F4;

// ============================== LOCAL CLASSES ================================

/**

 *  This is an internal utility class used by the JPLangUtil class

 *  and is intended for encapsulation only.

 *

 *  @lib JPLangUtil.lib

 *  @since 2.6

 */

class UnicodeTextUtil

    {

    public: // Query Functions

        /**

        * Determines if aUnicodeChar is a base Katakana that is capable

        * of being converted into either a Vioced or Semi-voiced Full-width

        * Katakana character.

        * If aSemiVoiced is true, then the check is only performed

        * for Semi-voiced conversion capability.

        *

        * @param aUnicodeChar The character to be tested.

        * @param aSemiVoiced  Whether or not the character is to be tested

        *                     as convertable to a Semi-voiced Full-width

        *                     Katakana, rather than just voiced.

        *

        * @return ETrue is the character is in fact convertable to either

        *         a voiced or semi-voiced fullwidth katakana character,

        *         depending on the aSemiVoiced flag.

        */

        static TBool IsFullWidthVoicedConvertableHalfWidthBaseKatakana

                             ( TText aUnicodeChar, TBool aSemiVoiced = EFalse );

        /**

        * Determines if aUnicodeChar is a  Vioced or Semi-voiced Full-width

        * Katakana character.

        * If aSemiVoiced is true, then the check is only performed

        * for Semi-voiced.

        *

        * @param aUnicodeChar The character to be tested.

        * @param aSemiVoiced  Whether or not the character is a Semi-voiced

        *                     Full-width Katakana, rather than just voiced.

        *

        * @return ETrue is the character is in fact a voiced or semi-voiced

        *         fullwidth katakana character, depending on the aSemiVoiced

        *         flag.

        */

        static TBool IsFullWidthVoicedKatakana( TText aUnicodeChar,

                                                TBool aSemiVoiced = EFalse);

    public: // Conversion Functions

        /**

        * Converts one Katakana character from either Half to Full-width

        * or vice versa, depending on the direction specified by aDirection

        *

        * @param aDirection Direction to convert.

        * @param aKatakanaChar The character to convert.

        *

        * @return The opposite width Katakana character.

        */

        static TChar ConvertKatakanaChar( TConvDirection aDirection,

                                          TText aKatakanaChar );

        /**

        * Converts one voiced Katakana character from either Half to Full-width

        * or vice versa, depending on the direction specified by aDirection,

        * and appends the converted character to the descriptor aTarget.

        * In the case that it is from Full to Half-width, it is necessary to

        * convert it into a base-katakana + (semi-)voiced mark pair, thus

        * the necessity for passing in the TDes reference return type.

        * In the case of converting from Half to Full-width, it is only

        * necessary to pass in a base-katakana that has a (semi-)voiced

        * Full-width counterpart.

        *

        * @param aDirection Direction to convert.

        * @param aVoicedKatakana The character to convert.

        * @param aTarget The descriptor to append the converted character(s) to.

        * @param aSemiVoiced ETrue if performing a Semi-voiced conversion.

        *                    Default is EFalse.

        */

        static void ConvertVoicedKatakanaCharAndAppendToTarget(

                                                   TConvDirection aDirection,

                                                   TText aVoicedKatakana,

                                                   TDes& aTarget,

                                                   TBool aSemiVoiced = EFalse );

        /**

        * Converts all special characters *in-place* from either Half to

        * Full-width or vice versa, depending on the direction specified

        * by aDirection

        *

        * @param aDirection Direction to convert.

        * @param aUnicodeText The character to convert.

        *

        * @return The number of converted special characters.

        */

        static TInt ConvertSpecialCharactersInPlace( TConvDirection aDirection,

                                                     TDes16& aUnicodeText );

        /**

        * Converts all ASCII *in-place* from either Half to

        * Full-width or vice versa, depending on the direction specified

        * by aDirection

        *

        * @param aDirection Direction to convert.

        * @param aUnicodeText The character to convert.

        *

        * @return The number of converted ASCII-range characters.

        */

        static TInt ConvertASCIIInPlace( TConvDirection aDirection,

                                         TDes16& aUnicodeText );

    };

// ============================= LOCAL FUNCTIONS ===============================

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

// UnicodeTextUtil::IsFullWidthVoicedConvertableHalfWidthBaseKatakana

// Determines if aUnicodeChar is a base Katakana that is capable

// of being converted into either a Vioced or Semi-voiced

// Full-width character.

// If aSemiVoiced is true, then the check is only performed

// for Semi-voiced conversion capability.

// Returns: ETrue if it is convertable.

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

//

TBool UnicodeTextUtil::IsFullWidthVoicedConvertableHalfWidthBaseKatakana

                                       ( TText aUnicodeChar, TBool aSemiVoiced )

    {

    if( aSemiVoiced )

        {

        return ( aUnicodeChar >= 0xff8a && aUnicodeChar <= 0xff8e );

        }

    else

        {

        return ( ( aUnicodeChar == 0xff73 ) ||

                 ( aUnicodeChar >= 0xff76 && aUnicodeChar <= 0xff7f ) ||

                 ( aUnicodeChar >= 0xff80 && aUnicodeChar <= 0xff84 ) ||

                 ( aUnicodeChar >= 0xff8a && aUnicodeChar <= 0xff8e ) ||

                 ( aUnicodeChar == 0xff9c ) ||

                 ( aUnicodeChar == 0xff66 ) );

        }

    }

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

// UnicodeTextUtil::IsFullWidthVoicedKatakana

// Determines if aUnicodeChar is Full-width Katakana.

// Returns: ETrue if it is Full-width Katakana.

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

//

TBool UnicodeTextUtil::IsFullWidthVoicedKatakana( TText aUnicodeChar,

                                                  TBool aSemiVoiced )

    {

    const TInt voicableRange( aSemiVoiced ?

                              KFullWidthSemiVoicableKatakanaRange :

                              KFullWidthVoicableKatakanaRange );

    const TText* const (*voicedTable) = aSemiVoiced ?

                              KHalfWidthBaseToFullWidthSemiVoicedKatakanaTable :

                              KHalfWidthBaseToFullWidthVoicedKatakanaTable;

    for( TInt i( 0 ); i < voicableRange; ++i )

        {

        if( aUnicodeChar == voicedTable[i][KFullWidthIndex] )

            {

            return ETrue;

            }

        }

    return EFalse;

    }

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

// UnicodeTextUtil::ConvertKatakanaChar

// Converts one Katakana Char in the direction specified by aDirection.

// Assumes aKatakanaChar is within range.

// Returns: A TText containing either the varient character or the character

//          itself, in the case there is no conversion.

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

//

TChar UnicodeTextUtil::ConvertKatakanaChar( TConvDirection aDirection,

                                            TText aKatakanaChar )

    {

    __ASSERT_DEBUG(

        JPLangUtil::IsKatakana( aKatakanaChar ) &&

        !IsFullWidthVoicedKatakana( aKatakanaChar ),

        User::Panic( KJPLangUtilPanic, EErrNotKatakana )

    );

    TChar convChar( aKatakanaChar );

    const TInt directionIndex( ( aDirection == EHalfToFullWidth ) ?

                                   KHalfWidthIndex : KFullWidthIndex );

    for( TInt i( 0 ); i < KHalfWidthKatakanaRange; ++i )

        {

        if( aKatakanaChar ==

                KHalfToFullWidthKatakanaCharTable[i][directionIndex] )

            {

            convChar = KHalfToFullWidthKatakanaCharTable[i][!directionIndex];

            break;

            }

        }

    return convChar;

    }

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

// UnicodeTextUtil::ConvertVoicedKatakanaChar

// Converts one Voiced Katakana Char in the direction specified by aDirection,

// and appends to the descriptor, aTarget.

// If aSemiVoiced is ETrue, then the code point is converted to the Semi-voiced

// variant.

// Assumes aVoicedKatakana is within range.

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

//

void UnicodeTextUtil::ConvertVoicedKatakanaCharAndAppendToTarget(

                                                      TConvDirection aDirection,

                                                      TText aVoicedKatakana,

                                                      TDes& aTarget,

                                                      TBool aSemiVoiced )

    {

    __ASSERT_DEBUG(

        IsFullWidthVoicedConvertableHalfWidthBaseKatakana( aVoicedKatakana ) ||

        IsFullWidthVoicedKatakana( aVoicedKatakana, aSemiVoiced ),

        User::Panic( KJPLangUtilPanic, EErrNotVoicedKatakana )

    );

    const TInt  voicableRange( aSemiVoiced ?

                               KFullWidthSemiVoicableKatakanaRange :

                               KFullWidthVoicableKatakanaRange );

    const TText* const (*voicedTable) = aSemiVoiced ?

                              KHalfWidthBaseToFullWidthSemiVoicedKatakanaTable :

                              KHalfWidthBaseToFullWidthVoicedKatakanaTable;

    if( aDirection == EHalfToFullWidth )

        {

        // In the case of Half Width, only the base character is needed for

        // the conversion

        for( TInt i( 0 ); i < voicableRange; ++i )

            {

            if( aVoicedKatakana == voicedTable[i][KHalfWidthIndex] )

                {

                const TChar uniChar( voicedTable[i][KFullWidthIndex] );

                aTarget.Append( uniChar );

                break;

                }

            }

        }

    else

        {

        for( TInt i( 0 ); i < voicableRange; ++i )

            {

            if( aVoicedKatakana == voicedTable[i][KFullWidthIndex] )

                {

                const TChar uniChar( voicedTable[i][KHalfWidthIndex] );

                aTarget.Append( uniChar );

                break;

                }

            }

        const TChar voicedSoundMark( aSemiVoiced ?

                                     KHalfWidthKatakanaSemiVoicedSoundMark :

                                     KHalfWidthKatakanaVoicedSoundMark );

        aTarget.Append( voicedSoundMark );

        }

    }

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

// UnicodeTextUtil::ConvertSpecialCharactersInPlace

// Converts all special characters in the aUnicodeText descriptor in-place

// that have both Full and Half-width variants.

// Conversion occurs in the direction specified by aDirection.

// Returns: The total number of characters converted.

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

//

TInt UnicodeTextUtil::ConvertSpecialCharactersInPlace

                             ( TConvDirection aDirection, TDes16& aUnicodeText )

    {

    TInt totalConverted( 0 );

    const TInt directionIndex( ( aDirection == EHalfToFullWidth ) ?

                                 KHalfWidthIndex : KFullWidthIndex );

    for( TInt i( 0 ); i < aUnicodeText.Length(); ++i )

        {

        const TText uniChar( aUnicodeText[i] );

        for( TInt j( 0 ); j < KHalfWidthSpecialCharRange; ++j )

            {

            if( uniChar == KHalfToFullWidthSpecialCharTable[j][directionIndex] )

                {

                aUnicodeText[i] =

                    KHalfToFullWidthSpecialCharTable[j][!directionIndex];

                totalConverted++;

                break;

                }

            }

        }

    return totalConverted;

    }

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

// UnicodeTextUtil::ConvertASCIIInPlace

// Converts all ASCII *in-place* from either Half to Full-width or vice versa,

// depending on the direction specified by aDirection.

// Returns: The total number of characters converted.

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

//

TInt UnicodeTextUtil::ConvertASCIIInPlace( TConvDirection aDirection,

                                           TDes16& aUnicodeText )

    {

    TInt totalConverted( 0 );

    TText lowerBound( ( aDirection == EHalfToFullWidth ) ?

                        KHalfWidthASCIILowerBound :

                        KFullWidthASCIILowerBound );

    TText upperBound( ( aDirection == EHalfToFullWidth ) ?

                        KHalfWidthASCIIUpperBound :

                        KFullWidthASCIIUpperBound );

    TInt offset( ( aDirection == EHalfToFullWidth ) ?

                   KHalfToFullWidthASCIIOffset :

                   -KHalfToFullWidthASCIIOffset );

    for( TInt i( 0 ); i < aUnicodeText.Length(); ++i )

        {

        const TText uniChar( aUnicodeText[i] );

        if( uniChar >= lowerBound && uniChar <= upperBound )

            {

            TText convertedChar( static_cast<TText>( uniChar + offset ) );

            aUnicodeText[i] = convertedChar;

            totalConverted++;

            }

        }

    return totalConverted;

    }

// EXPORTED FUNCTIONS

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

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

// JPLangUtil::ConvertHalfToFullWidth

// Converts all Half-width conformant text (including ASCII, Special Characters

// and Katakana) found in aUnicodeSource to their Full-width counterparts and

// places the resulting text into aUnicodeTarget.

// (detailed information about the parameters and return values can be found

//  in the header file)

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

//

EXPORT_C TInt JPLangUtil::ConvertHalfToFullWidth( const TDesC16& aUnicodeSource,

                                                  TDes16& aUnicodeTarget )

    {

    TInt totalConverted( 0 );

    // Special Characters are handled in the Katakana conversion...

    totalConverted =  ConvertHalfToFullWidthKatakana( aUnicodeSource,

                                                      aUnicodeTarget );

    totalConverted += UnicodeTextUtil::ConvertASCIIInPlace( EHalfToFullWidth,

                                                            aUnicodeTarget );

    return totalConverted;

    }

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

// JPLangUtil::ConvertFullToHalfWidth

// Converts all Full-width conformant text found in aUnicodeSource to their

// Full-width counterparts and places the resulting text into aUnicodeTarget.

// Only those characters with existing Half-width variants are converted. There

// will be a 2-for-1 conversion for each Full-width Voiced and Semi-voiced

// Katakana character.

// (detailed information about the parameters and return values can be found in

// the header file)

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

//

EXPORT_C TInt JPLangUtil::ConvertFullToHalfWidth( const TDesC16& aUnicodeSource,

                                                  TDes16& aUnicodeTarget )

    {

    TInt totalConverted( 0 );

    // Special Characters are handled in the Katakana conversion...

    totalConverted =  ConvertFullToHalfWidthKatakana( aUnicodeSource,

                                                      aUnicodeTarget );

    totalConverted += UnicodeTextUtil::ConvertASCIIInPlace( EFullToHalfWidth,

                                                            aUnicodeTarget );

    return totalConverted;

    }

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

// JPLangUtil::ConvertHalfToFullWidthKatakana

// Converts Half-width Katakana and Special Character text found in

// aUnicodeSource to their Full-width counterparts and places the resulting text

// into aUnicodeTarget.

// (detailed information about the parameters and return values can be found in

// the header file)

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

//

EXPORT_C TInt JPLangUtil::ConvertHalfToFullWidthKatakana

                       ( const TDesC16& aUnicodeSource, TDes16& aUnicodeTarget )

    {

    TInt totalConverted( 0 );

    const TInt length( aUnicodeSource.Length() );

    if( length > aUnicodeTarget.MaxLength() )

        {

        return KErrTooBig;

        }

    aUnicodeTarget.Zero();

    for( TInt i( 0 ); i < length; ++i )

        {

        const TText uniChar( aUnicodeSource[i] );

        // Check if the next character is a Half Width Katakana (Semi-)Voiced

        // Sound Mark and if the current character + the voiced sound mark have

        // a Full Width counterpart

        if( i + 1 < length )

            {

            const TBool isVoiced(

            ( UnicodeTextUtil::IsFullWidthVoicedConvertableHalfWidthBaseKatakana

                  ( uniChar ) &&

              ( aUnicodeSource[i + 1] == KHalfWidthKatakanaVoicedSoundMark )

            ) );

            const TBool isSemiVoiced(

            ( UnicodeTextUtil::IsFullWidthVoicedConvertableHalfWidthBaseKatakana

                  ( uniChar, ETrue ) &&

              ( aUnicodeSource[i + 1] == KHalfWidthKatakanaSemiVoicedSoundMark )

            ) );

            if( isVoiced || isSemiVoiced )

                {

                UnicodeTextUtil::ConvertVoicedKatakanaCharAndAppendToTarget(

                    EHalfToFullWidth,

                    uniChar,

                    aUnicodeTarget,

                    isSemiVoiced

                );

                i++; // Skip the (semi-)voice marker

                totalConverted++;

                continue;

                }

            }

        // If not, then just convert directly if in range

        if( uniChar >= KHalfWidthKatakanaLowerBound &&

            uniChar <= KHalfWidthKatakanaUpperBound )

            {

            aUnicodeTarget.Append(

                UnicodeTextUtil::ConvertKatakanaChar( EHalfToFullWidth,

                                                      uniChar )

            );

            totalConverted++;

            }

        // Else this is not Half Width Katakana, so copy directly...

        else

            {

            const TChar uniCharacter( uniChar );

            aUnicodeTarget.Append( uniCharacter );

            }

        }

    // Now handle special characters

    // This logic may be moved into this function to avoid another

    // loop over the text.

    totalConverted +=

        UnicodeTextUtil::ConvertSpecialCharactersInPlace( EHalfToFullWidth,

                                                          aUnicodeTarget );

    return totalConverted;

    }

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

// JPLangUtil::ConvertFullToHalfWidthKatakana

// Converts Full-width Katakana and Special Character text found in

// aUnicodeSource to their Half-width counterparts and places the resulting text

// into aUnicodeTarget. There will be a 2-for-1 conversion for each Full-width

// Voiced and Semi-voiced Katakana character.

// (detailed information about the parameters and return values can be found in

// the header file)

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

//

EXPORT_C TInt JPLangUtil::ConvertFullToHalfWidthKatakana

                       ( const TDesC16& aUnicodeSource, TDes16& aUnicodeTarget )

    {

    TInt totalConverted( 0 );

    const TInt length( aUnicodeSource.Length() );

    const TInt maxLength( aUnicodeTarget.MaxLength() );

    if( length > maxLength )

        {

        return KErrTooBig;

        }

    aUnicodeTarget.Zero();

    for( TInt i( 0 ); i < length; ++i )

        {

        const TText uniChar( aUnicodeSource[i] );

        // First check if this is this Full Width Katakana

        if( ( uniChar >= KFullWidthKatakanaLowerBound &&

              uniChar <= KFullWidthKatakanaUpperBound ) ||

            ( uniChar == KFullWidthKatakanaVoicedSoundMark ||

              uniChar == KFullWidthKatakanaSemiVoicedSoundMark ) )

            {

            // Then check if it is (Semi-)Voiced and convert it properly

            const TBool isVoiced(

                UnicodeTextUtil::IsFullWidthVoicedKatakana( uniChar )

            );

            const TBool isSemiVoiced(

                UnicodeTextUtil::IsFullWidthVoicedKatakana( uniChar, ETrue )

            );

            if( isVoiced || isSemiVoiced )

                {

                if( aUnicodeTarget.Length() + 2 > maxLength )

                    {

                    // This descriptor can't hold the new data

                    aUnicodeTarget.Zero();

                    return KErrTooBig;

                    }

                UnicodeTextUtil::ConvertVoicedKatakanaCharAndAppendToTarget(

                    EFullToHalfWidth,

                    uniChar,

                    aUnicodeTarget,

                    isSemiVoiced

                );

                totalConverted++;

                }

            else

                {

                if( aUnicodeTarget.Length() + 1 > maxLength )

                    {

                    // This descriptor can't hold the new data

                    aUnicodeTarget.Zero();

                    return KErrTooBig;

                    }

                aUnicodeTarget.Append(

                    UnicodeTextUtil::ConvertKatakanaChar(

                        EFullToHalfWidth,

                        uniChar

                    )

                );

                totalConverted++;

                }

            }

        // This is not Full Width Katakana, so copy directly...

        else

            {

            if( aUnicodeTarget.Length() + 1 > maxLength )

                {

                // This descriptor can't hold the new data

                aUnicodeTarget.Zero();

                return KErrTooBig;

                }

            const TChar uniCharacter( uniChar );

            aUnicodeTarget.Append( uniCharacter );

            }

        }

    // Now handle special characters

    // This logic may be moved into this function to avoid another loop over

    // the text

    totalConverted +=

        UnicodeTextUtil::ConvertSpecialCharactersInPlace( EFullToHalfWidth,

                                                          aUnicodeTarget );

    return totalConverted;

    }

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

// JPLangUtil::ConvertFullHiragnaToFullKatakana

// Converts Full-width Hiragana and Special Character text found in

// aUnicodeSource to their Full-width counterparts and places the

// resulting text into aUnicodeTarget.

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

//

EXPORT_C TInt JPLangUtil::ConvertFullHiragnaToFullKatakana

                       ( const TDesC16& aUnicodeSource, TDes16& aUnicodeTarget )

    {

    TInt totalConverted( 0 );

    const TInt length( aUnicodeSource.Length() );

    const TInt maxLength( aUnicodeTarget.MaxLength() );

    if( length > maxLength )

        {

        return KErrTooBig;

        }

    const TUint comp = KFullWidthKatakanaSmallA - KFullWidthHiraganaSmallA;

    aUnicodeTarget.Zero();

    for( TInt i( 0 ); i < length; ++i )

        {

        const TText uniChar( aUnicodeSource[i] );

        TText uniChar2(0);

        if (i + 1 < length)

            {

            uniChar2 = aUnicodeSource[i+1];

            }

        // First check if this is this Full Width Katakana

        if (KFullWidthHiraganaSmallA <= uniChar && uniChar <= KFullWidthHiraganaVU)

            {

            if (uniChar == KFullWidthHiraganaU

             && uniChar2 == KFullWidthHiraganaVoicedSound)

                {

                aUnicodeTarget.Append(KFullWidthKatakanaSmallVU);

                totalConverted++;

                i++;

                }

            else

                {

                TUint katakana = uniChar + comp;

                if (IsKatakana(katakana))

                    {

                    aUnicodeTarget.Append(katakana);

                    totalConverted++;

                    }

                }

            }

        else

            {

            aUnicodeTarget.Append(uniChar);

            totalConverted++;

            }

        }

    // Now handle special characters

    // This logic may be moved into this function to avoid another loop over

    // the text

    totalConverted +=

        UnicodeTextUtil::ConvertSpecialCharactersInPlace( EFullToHalfWidth,

                                                          aUnicodeTarget );

    return totalConverted;

    }

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

// JPLangUtil::IsKatakana

// Determines whether or not the character is Katakana

// (detailed information about the parameters and return values can be found in

// the header file)

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

//

EXPORT_C TBool JPLangUtil::IsKatakana( const TText aUnicodeChar )

    {

    return ( ( aUnicodeChar >= KFullWidthKatakanaLowerBound &&

               aUnicodeChar <= KFullWidthKatakanaUpperBound ) ||

             ( aUnicodeChar >= KHalfWidthKatakanaLowerBound &&

               aUnicodeChar <= KHalfWidthKatakanaUpperBound ) ||

             ( aUnicodeChar == KFullWidthKatakanaVoicedSoundMark ||

               aUnicodeChar == KFullWidthKatakanaSemiVoicedSoundMark ) );

    }

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

// JPLangUtil::IsHiragana

// Determines whether or not the character is Hiragana

// (detailed information about the parameters and return values can be found in

// the header file)

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

//

EXPORT_C TBool JPLangUtil::IsHiragana( const TText aUnicodeChar )

    {

    return ( ( aUnicodeChar >= 0x3041 && aUnicodeChar <= 0x3096 ) ||

             ( aUnicodeChar >= 0x3099 && aUnicodeChar <= 0x309f ) );

    }

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

// JPLangUtil::IsKanji

// Determines whether or not the character is a CJK Unified Ideograph (ExtA)

// (detailed information about the parameters and return values can be found in

// the header file)

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

//

EXPORT_C TBool JPLangUtil::IsKanji( const TText aUnicodeChar )

    {

    return( ( aUnicodeChar >= KCJKUnifiedIdiographLowerBound &&

              aUnicodeChar <= KCJKUnifiedIdiographUpperBound ) ||

            ( aUnicodeChar >= KCJKUnifiedIdeographExtALowerBound &&

              aUnicodeChar <= KCJKUnifiedIdeographExtAUpperBound ) );

    }

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

// JPLangUtil::IsHalfWidth

// Determines whether or not the character is UNICODE defined Half-width.

// (detailed information about the parameters and return values can be found in

// the header file)

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

//

EXPORT_C TBool JPLangUtil::IsHalfWidth( const TText aUnicodeChar )

    {

    return // HW Katakana

           ( ( aUnicodeChar >= 0xff61 && aUnicodeChar <= 0xff9f ) ||

           // ASCII

             ( aUnicodeChar >= 0x0020 && aUnicodeChar <= 0x007e ) ||

           // Special Characters

             ( aUnicodeChar == 0x00a2 || aUnicodeChar == 0x00a3 ||

               aUnicodeChar == 0x00a5 || aUnicodeChar == 0x00a6 ||

               aUnicodeChar == 0x00a9 || aUnicodeChar == 0x00ac ||

               aUnicodeChar == 0x00af || aUnicodeChar == 0x2985 ||

               aUnicodeChar == 0x2986 ) ||

           // HW Symbol Variants

             ( aUnicodeChar >= 0xffe8 && aUnicodeChar <= 0xffee ) );

    }

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

// JPLangUtil::IsFullWidth

// Determines whether or not the character is UNICODE defined Full-width.

// Essentially, all code values that are not Half-width.

// (detailed information about the parameters and return values can be found in

// the header file)

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

//

EXPORT_C TBool JPLangUtil::IsFullWidth( const TText aUnicodeChar )

    {

        return !IsHalfWidth( aUnicodeChar );

    }

// End of File