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