// Copyright (c) 1997-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:

//

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include "coninternal.h"

#endif //SYMBIAN_ENABLE_SPLIT_HEADERS

#include <concnf.h>

#include <conarc.h>

#include "CONSTD.H"

#include <f32file.h>

#include <s32file.h>

const TInt KConverterGranularity=2;

const TInt KMimeTypeGranularity=3;

const TInt KLanguageInfoGranularity=3;

const TInt KConarcPluginResourceId = 1;

TLanguageInfo::TLanguageInfo()

	:iLanguage(ELangEnglish), iTranslation(KNullDesC)

	{}

EXPORT_C TLanguageInfo::TLanguageInfo(TLanguage aLanguage,TTranslation aTranslation)

/** Constructor specifying language ID and localised name.

@param aLanguage Language ID

@param aTranslation Localised name in the specified language */

	{

	iLanguage=aLanguage;

	iTranslation=aTranslation;

	}

void TLanguageInfo::InternalizeL(RReadStream& aStream)

	{

	iLanguage=(TLanguage)aStream.ReadInt8L();

	aStream >> iTranslation;

	}

void TLanguageInfo::ExternalizeL(RWriteStream& aStream) const

	{

	aStream.WriteInt8L(iLanguage);

	aStream << iTranslation;

	}

TLanguage TLanguageInfo::Language()

	{

	return iLanguage;

	}

TTranslation TLanguageInfo::Translation()

	{

	return iTranslation;

	}

void TLanguageInfo::ReadFromResource(TResourceReader& aReader)

	{

	// Skip over extension

	aReader.ReadUint32();

	TInt enumInt=aReader.ReadInt16();

	iLanguage=static_cast<TLanguage>(enumInt);

    iTranslation=aReader.ReadTPtrC(); 

	}

EXPORT_C CMimeInfo::~CMimeInfo()

/** Destructor. */

	{

	delete iLanguageInfo;

	}

void CMimeInfo::ConstructL()

	{

	iLanguageInfo = new(ELeave) CArrayFixFlat<TLanguageInfo>(KLanguageInfoGranularity);

	}

CMimeInfo* CMimeInfo::NewLC(const CMimeInfo* aMimeInfo)

	{

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

	self->iMime=aMimeInfo->iMime;

	CleanupStack::PushL(self);

	self->ConstructL();

	TInt count = aMimeInfo->iLanguageInfo->Count();

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

		{

		TLanguageInfo info(aMimeInfo->iLanguageInfo->At(i).Language(),aMimeInfo->iLanguageInfo->At(i).Translation());

		self->iLanguageInfo->AppendL(info);

		}

	return self;

	}

EXPORT_C CMimeInfo* CMimeInfo::NewLC(TDataType& aMimeType)

/** Allocates and constructs a CMimeInfo for a specified data type, leaving the 

object on the cleanup stack.

@param aMime Data type

@return New CMimeInfo */

	{

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

	self->iMime=aMimeType;

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

CMimeInfo* CMimeInfo::NewL()

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void CMimeInfo::InternalizeL(RReadStream& aStream)

	{

	aStream >>iMime;

	TInt count = aStream.ReadInt8L();

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

		{

		TLanguageInfo info;

		info.InternalizeL(aStream);

		iLanguageInfo->AppendL(info);

		}

	}

void CMimeInfo::ExternalizeL(RWriteStream& aStream) const

	{

	aStream << iMime;

	TInt count = iLanguageInfo->Count();

	aStream.WriteInt8L(count);

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

		{

		iLanguageInfo->At(i).ExternalizeL(aStream);;

		}

	}

TDataType CMimeInfo::Mime()

	{

	return iMime;

	}

/**

 * return the translation for the current language

 * if the current lanuage does not exist the use english or the first in the list

 */

TTranslation CMimeInfo::Text()

	{

	TInt count = iLanguageInfo->Count();

	// no translations => return the mime description

	if (count==0)

		{

		TPtrC ptr=iMime.Des();

		if (ptr.Length()<=KMaxTranslation)

			return ptr;

		return (ptr.Left(KMaxTranslation));

		}

	TLanguage currentlanguage=User::Language();

	TInt englishIndex=0;

	for (TInt ii=0;ii<count;ii++)

		{

		if (iLanguageInfo->At(ii).Language()==currentlanguage)

			return iLanguageInfo->At(ii).Translation();

		if (iLanguageInfo->At(ii).Language()==ELangEnglish)

			englishIndex=ii;

		}

	return iLanguageInfo->At(englishIndex).Translation();

	}

EXPORT_C void CMimeInfo::AddLanguageL(TLanguageInfo aLang)

/** Adds a localised name for the data type.

@param aLang Localised name */

	{

	iLanguageInfo->AppendL(aLang);

	}

CMimeInfo* CMimeInfo::NewLC(TResourceReader& aReader)

	{

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

	CleanupStack::PushL(self);

	self->ConstructL(aReader);

	return self;

	}

void CMimeInfo::ConstructL(TResourceReader& aReader)

	{

    // read 

	// Skip over extension

	aReader.ReadUint32();

	iMime = aReader.ReadTPtrC8();

	iLanguageInfo = new(ELeave) CArrayFixFlat<TLanguageInfo>(KLanguageInfoGranularity);

    AddLanguageInfoL(aReader);

	}

void CMimeInfo::AddLanguageInfoL(TResourceReader& aReader)

	{

    const TInt numOfLangInfo=aReader.ReadInt16();

    for (TInt index = 0; index < numOfLangInfo ; index++)

        {

  		TLanguageInfo info;

		info.ReadFromResource(aReader);

		iLanguageInfo->AppendL(info);    

        }

	}

//

// class CCnaConverter

//

CCnaConverter* CCnaConverter::NewLC()

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

EXPORT_C CCnaConverter* CCnaConverter::NewL(TUid aUid)

/** Allocates and constructs a CCnaConverter for a specified converter.

@param aUid Converter UID

@return New CCnaConverter */

	{

	CCnaConverter* self=CCnaConverter::NewLC(aUid);

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C CCnaConverter* CCnaConverter::NewLC(TUid aUid)

/** Allocates and constructs a CCnaConverter for a specified converter, leaving 

the object on the cleanup stack.

@param aUid Converter UID

@return New CCnaConverter */

	{

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

	self->iUid = aUid;

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

EXPORT_C CCnaConverter* CCnaConverter::NewL(const CCnaConverter& aConverter)

/** Allocates and copies a new CCnaConverter.

@param aConverter Object to copy

@return New CCnaConverter */

	{

	CCnaConverter* self=CCnaConverter::NewLC(aConverter);

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C CCnaConverter* CCnaConverter::NewLC(const CCnaConverter& aConverter)

/** Allocates and copies a new CCnaConverter, leaving the object on the cleanup 

stack.

@param aConverter Object to copy

@return New CCnaConverter */

	{

	CCnaConverter* self=CCnaConverter::NewLC(aConverter.iUid);

	TInt count=aConverter.iMimeFrom->Count();

	TInt i;

	CMimeInfo* mimeinfo;

	for (i=0; i<count; i++)

		{

		mimeinfo=CMimeInfo::NewLC(aConverter.iMimeFrom->At(i));

		self->iMimeFrom->AppendL(mimeinfo);

		CleanupStack::Pop(mimeinfo);

		}

	count=aConverter.iMimeTo->Count();

	for (i=0; i<count; i++)

		{

		mimeinfo=CMimeInfo::NewLC(aConverter.iMimeTo->At(i));

		self->iMimeTo->AppendL(mimeinfo);

		CleanupStack::Pop(mimeinfo);

		}

	return self;

	}

CCnaConverter::CCnaConverter()

	{

	__DECLARE_NAME(_S("CCnaConverter"));

	}

EXPORT_C CCnaConverter::~CCnaConverter()

/** Destructor. */

	{

	if (iMimeFrom)

		iMimeFrom->ResetAndDestroy();

	delete iMimeFrom;

	if (iMimeTo)

		iMimeTo->ResetAndDestroy();

	delete iMimeTo;

	}

void CCnaConverter::ConstructL()

	{

	iMimeFrom= new (ELeave)CArrayPtrFlat<CMimeInfo>(KMimeTypeGranularity);

	iMimeTo= new (ELeave)CArrayPtrFlat<CMimeInfo>(KMimeTypeGranularity);

	}

EXPORT_C TBool CCnaConverter::MimeFrom(const TDataType& aMimeType) const

/** Tests if the specified source data type is available.

@param aMimeType Source data type

@return True if the converter supports the source data type, else false */

	{

	return FindMime(aMimeType,iMimeFrom);

	}

EXPORT_C TBool CCnaConverter::MimeTo(const TDataType& aMimeType) const

/** Tests if the specified target data type is available.

@param aMimeType Target data type

@return True if the converter supports the target data type, else false */

	{

	return FindMime(aMimeType,iMimeTo);

	}

TBool CCnaConverter::FindMime(const TDataType& aMimeType, const CArrayPtrFlat<CMimeInfo>* aList) const

// do the search

	{

	// !! need to use array searching code here?

	TInt count=aList->Count();

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

		{

		if (aMimeType==(*aList)[i]->Mime())

			return ETrue;

		}

	return EFalse;

	}

EXPORT_C TTranslation CCnaConverter::MimeFromText(const TDataType& aMimeType) const

/** Gets the localised name of the specified source data type.

@param aMimeType Source data type

@return Localised name of the source data type */

	{

	return FindMimeText(aMimeType,iMimeFrom);

	}

EXPORT_C TTranslation CCnaConverter::MimeToText(const TDataType& aMimeType) const

/** Gets the localised name of the specified target data type.

@param aMimeType Target data type

@return Localised name of the target data type */

	{

	return FindMimeText(aMimeType,iMimeTo);

	}

TTranslation CCnaConverter::FindMimeText(const TDataType& aMimeType, const CArrayPtrFlat<CMimeInfo>* aList) const

// do the search

	{

	TInt count=aList->Count();

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

		{

		if (aMimeType==(*aList)[i]->Mime())

			return (*aList)[i]->Text();

		}

	return KNullDesC();

	}

EXPORT_C TInt CCnaConverter::CountFrom() const

/** Gets the number of source data types for the converter.

@return Number of source data types */

	{

	return iMimeFrom->Count();

	}

EXPORT_C TInt CCnaConverter::CountTo() const

/** Gets the number of target data types for the converter.

@return Number of target data types */

	{

	return iMimeTo->Count();

	}

EXPORT_C TDataType CCnaConverter::MimeFrom(TInt aIndex) const

/** Gets the n'th source data type of the converter.

@param aIndex Index of the source data type to get

@return Source data type */

	{

	return iMimeFrom->At(aIndex)->Mime();

	}

EXPORT_C TDataType CCnaConverter::MimeTo(TInt aIndex) const

/** Gets the n'th target data type of the converter.

@param aIndex Index of the target data type to get

@return Target data type */

	{

	return iMimeTo->At(aIndex)->Mime();

	}

EXPORT_C void CCnaConverter::SetUid(TUid aUid)

/** Sets the converter UID.

@param aUid Converter UID */

	{

	iUid = aUid;

	}

EXPORT_C TTranslation CCnaConverter::MimeFromText(TInt aIndex) const

/** Gets the localised name of the n'th source data type.

@param aIndex Index of the source data type

@return Localised name of the source data type */

	{

	return iMimeFrom->At(aIndex)->Text();

	}

EXPORT_C TTranslation CCnaConverter::MimeToText(TInt aIndex) const

/** Gets the localised name of the n'th target data type.

@param aIndex Index of the target data type

@return Localised name of the target data type */

	{

	return iMimeTo->At(aIndex)->Text();

	}

CCnaConverter* CCnaConverter::NewL(TUid aUid,TResourceReader& aReader)

	{

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

	CleanupStack::PushL(self);

	self->ConstructL(aUid, aReader);

	CleanupStack::Pop(self);

	return self;

	}

// used when creating object from a resource file.

void CCnaConverter::ConstructL(TUid aUid,TResourceReader& aReader)

	{

	iUid=aUid;

	iMimeFrom= new (ELeave)CArrayPtrFlat<CMimeInfo>(KMimeTypeGranularity);

	AddMimeDataL(aReader,*iMimeFrom);

	iMimeTo= new (ELeave)CArrayPtrFlat<CMimeInfo>(KMimeTypeGranularity);

	AddMimeDataL(aReader,*iMimeTo);

	}

void CCnaConverter::AddMimeDataL(TResourceReader& aReader,CArrayPtrFlat<CMimeInfo>& aMimeInfo)

	{

    const TInt number=aReader.ReadInt16();

    for (TInt index = 0; index < number ; index++)

		{

        CMimeInfo* mimeInfo=CMimeInfo::NewLC(aReader);

		aMimeInfo.AppendL(mimeInfo);

		CleanupStack::Pop(mimeInfo); // now mimeInfo safely in an array   

        }

	}

//

// class CCnaConvInfoFile2

//

CCnaConvInfoFile2::~CCnaConvInfoFile2()

	{

	if (iConverters)

		{

		iConverters->ResetAndDestroy();

		}

	delete iConverters;

	iResourceFile.Close();

	iFs.Close();

	}

void CCnaConvInfoFile2::ConstructL()

	{

	User::LeaveIfError(iFs.Connect());

	iConverters=new(ELeave) CArrayPtrFlat<CCnaConverter>(KConverterGranularity);

	}

//

// class CCnaConvInfoFileReader2

//

EXPORT_C CCnaConvInfoFileReader2* CCnaConvInfoFileReader2::NewLC(const TDesC& aFileName)

/** Constructs a CCnaConvInfoFileReader2 object for a given .rsc file.

@param aFileName The .rsc file name.

@return The new CCnaConvInfoFileReader2 object. */

	{

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

	CleanupStack::PushL(self);

	self->ConstructL(aFileName);

	return self;

	}

EXPORT_C CCnaConvInfoFileReader2* CCnaConvInfoFileReader2::NewL(const TDesC& aFileName)

/** Constructs a CCnaConvInfoFileReader2 object for a given .rsc file.

@param aFileName The .rsc file name.

@return The new CCnaConvInfoFileReader2 object. */

	{

	CCnaConvInfoFileReader2* self=CCnaConvInfoFileReader2::NewLC(aFileName);

	CleanupStack::Pop(self); 

	return self;

	}

CCnaConvInfoFileReader2::CCnaConvInfoFileReader2()

	{

	}

void CCnaConvInfoFileReader2::RestoreConverterL(TResourceReader& aReader)

	{

	// Skip over extension

	aReader.ReadUint32();

	TUid converterUid;

	converterUid.iUid=aReader.ReadInt32();

	CCnaConverter* tempConv= CCnaConverter::NewL(converterUid,aReader);