/*

* Copyright (c) 2005 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: 

*

*/

#include <e32svr.h>

#include <e32std.h>

#include <e32def.h>

#include <e32des8.h> 

#include "unicodeconv.h"

//replacement character to be used when unicode cannot be converted

const TUint8 KForeignReplacement = 0x5F;

//This function converts from Unicoded characters, to foreign characters and adds them into a descriptor

void UnicodeConv::ConvertFromUnicodeL(TDes8& aForeign, const TDesC16& aUnicode)

    {	

    const TInt unicodeLength = aUnicode.Length();

    //loop going through the character of the unicode descriptor

    for(TInt i=0; i<unicodeLength; i++)

        {

        const TUint16 unicodeChar = aUnicode[i];

        if (aForeign.Length() >= aForeign.MaxLength())

            {

            User::Leave(KErrOverflow);

            }

        //charcters from 0x0000 to 0x007F, can be mapped directly

        if(unicodeChar<0x0080)

            {

            aForeign.Append(static_cast<TUint8>(unicodeChar));

            }

        else

            {

            TInt trailByte = KErrNotFound;

            TInt returnValue = TConvDataStruct::ConvertSingleUnicode(unicodeChar,trailByte);

            if(returnValue!=KErrNotFound)

                {

                if(trailByte!=KErrNotFound)		

                    {

                    if (aForeign.Length() + 2 <= aForeign.MaxLength())

                        {											

                        aForeign.Append(static_cast<TUint8>(returnValue));

                        aForeign.Append(static_cast<TUint8>(trailByte));						

                        }

                    else

                        {

                        User::Leave(KErrOverflow);

                        }	

                    }

                else

                    aForeign.Append(static_cast<TUint8>(returnValue));

                }		

            else

                aForeign.Append(KForeignReplacement);

            } 

        }		

    }

//This function converts from foreign characters into unicode and adds them into a descriptor

void UnicodeConv::ConvertToUnicodeL(TDes16& aUnicode, const TDesC8& aForeign)

    {

    const TInt foreignLength = aForeign.Length();

    //loop going through the characters of the foreign descriptor

    for(TInt i = 0; i<foreignLength; i++)

        {

        const TUint8 leadForeign = aForeign[i];

        if (aUnicode.Length() >= aUnicode.MaxLength())

            {

            User::Leave(KErrOverflow);

            }

        TUint8 tailForeign = 0x00;

        //charcters from 0x00 to 0x7F, can be mapped directly

        if(leadForeign < 0x80)

            aUnicode.Append(static_cast<TUint16>(leadForeign));

        else

            {

            if((i+1)<foreignLength)

                tailForeign = aForeign[i+1];

            const TLeadOrSingle* structPtr = TConvDataStruct::KFirstByteConversions + (leadForeign-0x80);

            if(structPtr->iUnicodeIfSingle)

                aUnicode.Append(structPtr->iUnicodeIfSingle);

            else

                {

                if(TConvDataStruct::KMinTrailByte<=tailForeign && tailForeign<=TConvDataStruct::KMaxTrailByte)

                    aUnicode.Append(TConvDataStruct::KDoubleByteConversions[structPtr->iDoubleByteIndex+

                        (tailForeign - TConvDataStruct::KMinTrailByte)]);

                else

                    aUnicode.Append(0xFFFD);

                i++;

                }

            }

        }  

    }

TBool UnicodeConv::IsLegalShortNameCharacter (TUint aCharacter)

    {

    if (aCharacter>=0x0080)

        {

        if (aCharacter>0xFFFF)

            return EFalse;

        TInt trailByte = KErrNotFound;

        TInt returnValue = TConvDataStruct::ConvertSingleUnicode(aCharacter,trailByte);

        if(returnValue!=KErrNotFound)

            return ETrue;

        }

    if(aCharacter>= 'a' && aCharacter<= 'z')

        return(ETrue);

    if(aCharacter>= 'A' && aCharacter<= 'Z')

        return(ETrue);

    if(aCharacter>= '0' && aCharacter<= '9')

        return(ETrue);

    switch (aCharacter)

        {

        case '\'':

        case '`':

        case '-':

        case '_':

        case '^':

        case '$':

        case '~':

        case '!':

        case '#':

        case '%':

        case '&':

        case '{':

        case '}':

        case '@':

        case '(':

        case ')':

            return ETrue;

        default:

            return EFalse;

        }

    }