// 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:

//

#include <f32file.h>

#include <e32uid.h>

#include <s32file.h>

#include "B64CONV.H"

#include "TXCONV.H"

#include "QPCONV.H"

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include "coninternal.h"

#endif //SYMBIAN_ENABLE_SPLIT_HEADERS

#include "CONLIST.H"

#include "CONSTD.H"

const TInt KConverterListGranularity=5;

// 

// class CCnaConverterList

//

EXPORT_C CCnaConverterList* CCnaConverterList::NewL()

/** Allocates and constructs a CCnaConverterList.

@return New converter list */

	{

	CCnaConverterList* self=CCnaConverterList::NewLC();

	CleanupStack::Pop(); // self

	return self;

	}

EXPORT_C CCnaConverterList* CCnaConverterList::NewLC()

/** Allocates and constructs a CCnaConverterList, leaving the object on the cleanup 

stack.

@return New converter list */

 	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

CCnaConverterList::CCnaConverterList()

	{

	__DECLARE_NAME(_S("CCnaConverterList"));

	}

void CCnaConverterList::ConstructL()

	{

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

	}

EXPORT_C CCnaConverterList::~CCnaConverterList()

/** Destructor.

This releases all loaded converter DLLs. */

	{

	if (iConverters)

		{

		iConverters->ResetAndDestroy();

		delete iConverters;

		}

	iImplementationArray.ResetAndDestroy();

	}

EXPORT_C void CCnaConverterList::Release()

/** Legacy function, do not use. */

	{

	}

EXPORT_C TInt CCnaConverterList::CountL()

/** Gets the total number of converters.

It can leave because it needs to rescan the disk to refresh 

the list of converters.

@return Total number of converters */

	{

	if (!iDoneScan)

		UpdateL();

	TInt count=0;

	return count+iImplementationArray.Count();

	}

EXPORT_C CConverterBase* CCnaConverterList::NewConverterL(TUid aUid)

/** Locates the converter with the specified UID, loads its associated DLL

and returns a pointer to it.

@param aUid Converter UID

@return Converter with the specified UID, or NULL if there is no suitable converter */

	{

	CConverterBase* base=ConverterListUtil::UtilityConverterL(aUid);

	if (base)

		return base;

	if (!iDoneScan)

		UpdateL();

	TInt i;

	TInt count;

	count = iImplementationArray.Count();

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

		{

		if (iImplementationArray[i]->ImplementationUid()==aUid)

			{

			return LoadConverterL(iImplementationArray[i]->ImplementationUid());

			}

		}

	return NULL;

	}

EXPORT_C void CCnaConverterList::UpdateL()

/** Requests a rescan of the disk to refresh the list of converters. */

	{

	// delete old array and populate it with new values

	iImplementationArray.ResetAndDestroy();

	REComSession::ListImplementationsL(KUidConverterDll16,iImplementationArray);

	for (TInt i=0; i<iImplementationArray.Count(); i++)

		{// load the conarc-plugin resource file. This should be set to 1 in

		 // the ecom resource file to show there is extra file to load

		if (iImplementationArray[i]->OpaqueData().Length()!=0 )

			{ 

			_LIT(KPath,"z:\\resource\\convert\\");

			_LIT(KExtension,".rsc");

			TFileName resourceFile;

			resourceFile.Copy(KPath);

			resourceFile.AppendNum((TInt)iImplementationArray[i]->ImplementationUid().iUid, EHex);

			resourceFile.Append(KExtension);

			CCnaConvInfoFileReader2* readConverter=CCnaConvInfoFileReader2::NewL(resourceFile);

			CleanupStack::PushL(readConverter);

			readConverter->RestoreL();

			const TInt converterCount = readConverter->Count();

			for (TInt j = 0 ; j < converterCount ; j++ )

				{

				CCnaConverter* tempConv= readConverter->AtL(j);

				CleanupStack::PushL(tempConv);

				iConverters->AppendL(tempConv);

				CleanupStack::Pop(tempConv);

				}

			CleanupStack::PopAndDestroy(readConverter);

			}	

		}

	iDoneScan=ETrue;

	}

EXPORT_C TUid CCnaConverterList::ConvFromL(const TDataType& aMimeType)

// searches for a particular converter that converts from the specified Mime Type

// 

// To be called iteratively to find all available converters

// for the specified mime type

// 

// returns the Uid of the converter or NULL when no converters remain

/** Gets the UID of the converter that converts from the specified data type.

@param aMimeType Source data type

@return Converter UID */

	{

	TInt i;

	TInt count=iConverters->Count();

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

		{

		CCnaConverter* converter = iConverters->At(i);

		if (converter->MimeFrom(aMimeType))

			{

			return converter->Uid();

			}

		}

	return KNullUid;

	}

EXPORT_C TUid CCnaConverterList::ConvToL(const TDataType& aMimeType)

// searches for a particular converter that converts to the specified Mime Type

// as for GetConvFromL() but specifing a target mime type

/** Gets the UID of the converter that converts to a specified data type.

@param aMimeType Target data type

@return Converter UID */

	{

	TInt i;

	TInt count=iConverters->Count();

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

		{

		CCnaConverter* converter = iConverters->At(i);

		if (converter->MimeTo(aMimeType))

			{

			return converter->Uid();

			}

		}

	return KNullUid;

	}

EXPORT_C TUid CCnaConverterList::ConverterL(const TDataType& aFrom,const TDataType& aTo)

/** Gets the UID of the converter that converts to and from the specified data types.

@param aFrom Source data type

@param aTo Target data type

@return Converter UID */

	{

	if (!iDoneScan)

		UpdateL();

	TInt ii;

	TInt count=iConverters->Count();

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

		{

		const CCnaConverter* conv=iConverters->At(ii);

		if (conv->MimeFrom(aFrom) && conv->MimeTo(aTo))

			{

			return conv->Uid();

			}

		}

	return KNullUid;

	}

// Compiles a list of converters that convert FROM a mime type.

// Produces an array of the translations of the types they convert FROM 

// and a corresponding array of uids.

// The data type to convert TO is supplied

EXPORT_C void CCnaConverterList::ConvFromListL(const TDataType& aMimeType,CArrayFix<SConverterInfo>* aSConverterInfoArray)

/** Gets a list of converters that convert from a specified data type.

@param aMimeType Source data type

@param aSConverterInfoArray On return, array of converter information objects 

for all suitable converters */

	{

	ASSERT(aSConverterInfoArray->Count()==0);

	if (!iDoneScan)

		UpdateL();

	TInt i;

	TInt count = iConverters->Count();

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

		{

		CCnaConverter* conv = iConverters->At(i);

		//does converter support this type

		if (conv->MimeFrom(aMimeType) )

			{

			const TInt countTo = conv->CountTo();

			//add the types that it converts to

			for( TInt j=0;j<countTo;j++)

				{

				SConverterInfo info;

				info.iTranslation=conv->MimeToText(j);

				info.iUid=conv->Uid();

				info.iIndex=j;

				aSConverterInfoArray->AppendL(info);

				}

			}

		}

	}

// Compiles a list of converters that convert TO a mime type.

// Produces an array of the translations of the types they convert TO

// and a corresponding array of uids.

// The data type to convert FROM is supplied

EXPORT_C void CCnaConverterList::ConvToListL(const TDataType& aMimeType,CArrayFix<SConverterInfo>* aSConverterInfoArray)

/** Gets a list of converters that convert to a specified data type.

@param aMimeType Target data type

@param aSConverterInfoArray On return, an array of converter information objects 

for all suitable converters */

	{

	ASSERT(aSConverterInfoArray->Count()==0);

	if (!iDoneScan)

		UpdateL();

	TInt i;

	TInt count = iConverters->Count();

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

		{

		CCnaConverter* conv = iConverters->At(i);

		//does converter support this type

		if (conv->MimeTo(aMimeType) )

			{

			const TInt countFrom=conv->CountFrom();

			for( TInt j=0;j<countFrom;j++)

				{

				SConverterInfo info;

				info.iTranslation=conv->MimeFromText(j);

				info.iUid=conv->Uid();

				info.iIndex=j;

				aSConverterInfoArray->AppendL(info);

				}

			}

		}

	}

EXPORT_C TInt CCnaConverterList::MimeTypeFrom(TDataType& aDataType,const SConverterInfo& aInfo) const

/** Gets converter information for a specified source data type.

@param aDataType Source data type

@param aConverterInfo On return, converter information for a suitable converter

@return KErrNone if a suitable converter was found, else KErrNotFound */	

	{

	TInt i;

	TInt count = iConverters->Count();

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

		{

		const CCnaConverter* conv = iConverters->At(i);

		if (conv->Uid()==aInfo.iUid)

			{

			if((aInfo.iIndex>=0) && (aInfo.iIndex<conv->CountFrom()))

				{

				aDataType=conv->MimeFrom(aInfo.iIndex);

				return KErrNone;

				}

			break;

			}

		}

	return KErrNotFound;

	}

EXPORT_C TInt CCnaConverterList::MimeTypeTo(TDataType& aDataType,const SConverterInfo& aInfo) const

/** Gets converter information for a specified target data type.

@param aDataType Target data type

@param aConverterInfo On return, converter information for a suitable converter

@return KErrNone if a suitable converter was found, else KErrNotFound */

	{

	TInt i;

	TInt count = iConverters->Count();

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

		{

		const CCnaConverter* conv = iConverters->At(i);

		if (conv->Uid()==aInfo.iUid)

			{

			if(aInfo.iIndex>=0 && aInfo.iIndex<conv->CountTo())

				{

				aDataType=conv->MimeTo(aInfo.iIndex);

				return KErrNone;

				}

			break;

			}

		}

	return KErrNotFound;

	}

CConverterBase* CCnaConverterList::LoadConverterL(TUid aImplUid)

	{

	return CConverterBase2::CreateConverterL(aImplUid);

	}

CConverterBase* ConverterListUtil::UtilityConverterL(TUid aUid)

	{

	switch (aUid.iUid)

		{

	case KBase64Decoder:

		return new(ELeave) CBase64Decoder();

	case KBase64Encoder:

		return new(ELeave) CBase64Encoder();

	case KQuotedPrintableToText:

		return new(ELeave) CQpToTxtCnv();

	case KTextToQuotedPrintable:

		return new(ELeave) CTxtToQpCnv();

	case KEtextToText:

		return new(ELeave) CEtToTxtCnv();

	case KTextToEtext:

		return new(ELeave) CTxtToEtCnv();

	case KTextToEtextNoTrim:

		return new(ELeave) CTxtToEtCnv(ETrue);	

	default:

		return NULL;

		}

	}

TInt ConverterListUtil::CountUtilityConverters()

	{

	return 6;

	}