/*
* 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;
        }
    }