1 // Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 #ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

    17 #include "coninternal.h"

    18 #endif //SYMBIAN_ENABLE_SPLIT_HEADERS

    19 #include <concnf.h>

    20 #include <conarc.h>

    21 #include "CONSTD.H"

    22 

    23 #include <f32file.h>

    24 #include <s32file.h>

    25 

    26 const TInt KConverterGranularity=2;

    27 const TInt KMimeTypeGranularity=3;

    28 const TInt KLanguageInfoGranularity=3;

    29 const TInt KConarcPluginResourceId = 1;

    30 

    31 TLanguageInfo::TLanguageInfo()

    32 	:iLanguage(ELangEnglish), iTranslation(KNullDesC)

    33 	{}

    34 

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

    36 /** Constructor specifying language ID and localised name.

    37 

    38 @param aLanguage Language ID

    39 @param aTranslation Localised name in the specified language */

    40 	{

    41 	iLanguage=aLanguage;

    42 	iTranslation=aTranslation;

    43 	}

    44 

    45 void TLanguageInfo::InternalizeL(RReadStream& aStream)

    46 	{

    47 	iLanguage=(TLanguage)aStream.ReadInt8L();

    48 	aStream >> iTranslation;

    49 	}

    50 

    51 void TLanguageInfo::ExternalizeL(RWriteStream& aStream) const

    52 	{

    53 	aStream.WriteInt8L(iLanguage);

    54 	aStream << iTranslation;

    55 	}

    56 

    57 TLanguage TLanguageInfo::Language()

    58 	{

    59 	return iLanguage;

    60 	}

    61 

    62 TTranslation TLanguageInfo::Translation()

    63 	{

    64 	return iTranslation;

    65 	}

    66 

    67 void TLanguageInfo::ReadFromResource(TResourceReader& aReader)

    68 	{

    69 	// Skip over extension

    70 	aReader.ReadUint32();

    71 	TInt enumInt=aReader.ReadInt16();

    72 	iLanguage=static_cast<TLanguage>(enumInt);

    73     iTranslation=aReader.ReadTPtrC(); 

    74 	}

    75 

    76 EXPORT_C CMimeInfo::~CMimeInfo()

    77 /** Destructor. */

    78 	{

    79 	delete iLanguageInfo;

    80 	}

    81 

    82 void CMimeInfo::ConstructL()

    83 	{

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

    85 	}

    86 

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

    88 	{

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

    90 	self->iMime=aMimeInfo->iMime;

    91 	

    92 	CleanupStack::PushL(self);

    93 	self->ConstructL();

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

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

    96 		{

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

    98 		self->iLanguageInfo->AppendL(info);

    99 		}

   100 	return self;

   101 	}

   102 

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

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

   105 object on the cleanup stack.

   106 

   107 @param aMime Data type

   108 @return New CMimeInfo */

   109 	{

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

   111 	self->iMime=aMimeType;

   112 	CleanupStack::PushL(self);

   113 	self->ConstructL();

   114 	return self;

   115 	}

   116 

   117 CMimeInfo* CMimeInfo::NewL()

   118 	{

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

   120 	CleanupStack::PushL(self);

   121 	self->ConstructL();

   122 	CleanupStack::Pop(self);

   123 	return self;

   124 	}

   125 

   126 void CMimeInfo::InternalizeL(RReadStream& aStream)

   127 	{

   128 	aStream >>iMime;

   129 	TInt count = aStream.ReadInt8L();

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

   131 		{

   132 		TLanguageInfo info;

   133 		info.InternalizeL(aStream);

   134 		iLanguageInfo->AppendL(info);

   135 

   136 		}

   137 	}

   138 

   139 void CMimeInfo::ExternalizeL(RWriteStream& aStream) const

   140 	{

   141 	aStream << iMime;

   142 	TInt count = iLanguageInfo->Count();

   143 	aStream.WriteInt8L(count);

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

   145 		{

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

   147 		}

   148 	}

   149 

   150 TDataType CMimeInfo::Mime()

   151 	{

   152 	return iMime;

   153 	}

   154 

   155 /**

   156  * return the translation for the current language

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

   158  */

   159 TTranslation CMimeInfo::Text()

   160 	{

   161 	TInt count = iLanguageInfo->Count();

   162 	// no translations => return the mime description

   163 	if (count==0)

   164 		{

   165 		TPtrC ptr=iMime.Des();

   166 		if (ptr.Length()<=KMaxTranslation)

   167 			return ptr;

   168 		return (ptr.Left(KMaxTranslation));

   169 		}

   170 	TLanguage currentlanguage=User::Language();

   171 	TInt englishIndex=0;

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

   173 		{

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

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

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

   177 			englishIndex=ii;

   178 		}

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

   180 	}

   181 

   182 EXPORT_C void CMimeInfo::AddLanguageL(TLanguageInfo aLang)

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

   184 

   185 @param aLang Localised name */

   186 	{

   187 	iLanguageInfo->AppendL(aLang);

   188 	}

   189 

   190 CMimeInfo* CMimeInfo::NewLC(TResourceReader& aReader)

   191 	{

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

   193 	CleanupStack::PushL(self);

   194 	self->ConstructL(aReader);

   195 	return self;

   196 	}

   197 

   198 void CMimeInfo::ConstructL(TResourceReader& aReader)

   199 	{

   200     // read 

   201 	// Skip over extension

   202 	aReader.ReadUint32();

   203 	iMime = aReader.ReadTPtrC8();

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

   205     AddLanguageInfoL(aReader);

   206 	}

   207 

   208 void CMimeInfo::AddLanguageInfoL(TResourceReader& aReader)

   209 	{

   210     const TInt numOfLangInfo=aReader.ReadInt16();

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

   212         {

   213   		TLanguageInfo info;

   214 		info.ReadFromResource(aReader);

   215 		iLanguageInfo->AppendL(info);    

   216         }

   217 	}

   218 

   219 //

   220 // class CCnaConverter

   221 //

   222 

   223 CCnaConverter* CCnaConverter::NewLC()

   224 	{

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

   226 	CleanupStack::PushL(self);

   227 	self->ConstructL();

   228 	return self;

   229 	}

   230 

   231 EXPORT_C CCnaConverter* CCnaConverter::NewL(TUid aUid)

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

   233 

   234 @param aUid Converter UID

   235 @return New CCnaConverter */

   236 	{

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

   238 	CleanupStack::Pop(self);

   239 	return self;

   240 	}

   241 

   242 EXPORT_C CCnaConverter* CCnaConverter::NewLC(TUid aUid)

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

   244 the object on the cleanup stack.

   245 

   246 @param aUid Converter UID

   247 @return New CCnaConverter */

   248 	{

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

   250 	self->iUid = aUid;

   251 	CleanupStack::PushL(self);

   252 	self->ConstructL();

   253 	return self;

   254 	}

   255 

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

   257 /** Allocates and copies a new CCnaConverter.

   258 

   259 @param aConverter Object to copy

   260 @return New CCnaConverter */

   261 	{

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

   263 	CleanupStack::Pop(self);

   264 	return self;

   265 	}

   266 

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

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

   269 stack.

   270 

   271 @param aConverter Object to copy

   272 @return New CCnaConverter */

   273 	{

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

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

   276 	TInt i;

   277 	CMimeInfo* mimeinfo;

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

   279 		{

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

   281 		self->iMimeFrom->AppendL(mimeinfo);

   282 		CleanupStack::Pop(mimeinfo);

   283 		}

   284 	count=aConverter.iMimeTo->Count();

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

   286 		{

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

   288 		self->iMimeTo->AppendL(mimeinfo);

   289 		CleanupStack::Pop(mimeinfo);

   290 		}

   291 	return self;

   292 	}

   293 

   294 

   295 CCnaConverter::CCnaConverter()

   296 	{

   297 	__DECLARE_NAME(_S("CCnaConverter"));

   298 	}

   299 

   300 EXPORT_C CCnaConverter::~CCnaConverter()

   301 /** Destructor. */

   302 	{

   303 	if (iMimeFrom)

   304 		iMimeFrom->ResetAndDestroy();

   305 	delete iMimeFrom;

   306 	if (iMimeTo)

   307 		iMimeTo->ResetAndDestroy();

   308 	delete iMimeTo;

   309 	}

   310 

   311 void CCnaConverter::ConstructL()

   312 	{

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

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

   315 	}

   316 

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

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

   319 

   320 @param aMimeType Source data type

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

   322 	{

   323 	return FindMime(aMimeType,iMimeFrom);

   324 	}

   325 

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

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

   328 

   329 @param aMimeType Target data type

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

   331 	{

   332 	return FindMime(aMimeType,iMimeTo);

   333 	}

   334 

   335 

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

   337 // do the search

   338 	{

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

   340 	TInt count=aList->Count();

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

   342 		{

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

   344 			return ETrue;

   345 		}

   346 	return EFalse;

   347 	}

   348 

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

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

   351 

   352 @param aMimeType Source data type

   353 @return Localised name of the source data type */

   354 	{

   355 	return FindMimeText(aMimeType,iMimeFrom);

   356 	}

   357 

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

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

   360 

   361 @param aMimeType Target data type

   362 @return Localised name of the target data type */

   363 	{

   364 	return FindMimeText(aMimeType,iMimeTo);

   365 	}

   366 

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

   368 // do the search

   369 	{

   370 	TInt count=aList->Count();

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

   372 		{

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

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

   375 		}

   376 	return KNullDesC();

   377 	}

   378 

   379 EXPORT_C TInt CCnaConverter::CountFrom() const

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

   381 

   382 @return Number of source data types */

   383 	{

   384 	return iMimeFrom->Count();

   385 	}

   386 

   387 EXPORT_C TInt CCnaConverter::CountTo() const

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

   389 

   390 @return Number of target data types */

   391 	{

   392 	return iMimeTo->Count();

   393 	}

   394 

   395 EXPORT_C TDataType CCnaConverter::MimeFrom(TInt aIndex) const

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

   397 

   398 @param aIndex Index of the source data type to get

   399 @return Source data type */

   400 	{

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

   402 	}

   403 

   404 EXPORT_C TDataType CCnaConverter::MimeTo(TInt aIndex) const

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

   406 

   407 @param aIndex Index of the target data type to get

   408 @return Target data type */

   409 	{

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

   411 	}

   412 

   413 EXPORT_C void CCnaConverter::SetUid(TUid aUid)

   414 /** Sets the converter UID.

   415 

   416 @param aUid Converter UID */

   417 	{

   418 	iUid = aUid;

   419 	}

   420 

   421 EXPORT_C TTranslation CCnaConverter::MimeFromText(TInt aIndex) const

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

   423 

   424 @param aIndex Index of the source data type

   425 @return Localised name of the source data type */

   426 	{

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

   428 	}

   429 

   430 EXPORT_C TTranslation CCnaConverter::MimeToText(TInt aIndex) const

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

   432 

   433 @param aIndex Index of the target data type

   434 @return Localised name of the target data type */

   435 	{

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

   437 	}

   438 

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

   440 	{

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

   442 	CleanupStack::PushL(self);

   443 	self->ConstructL(aUid, aReader);

   444 	CleanupStack::Pop(self);

   445 	return self;

   446 	}

   447 

   448 // used when creating object from a resource file.

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

   450 	{

   451 	iUid=aUid;

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

   453 	AddMimeDataL(aReader,*iMimeFrom);

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

   455 	AddMimeDataL(aReader,*iMimeTo);

   456 	}

   457 

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

   459 	{

   460     const TInt number=aReader.ReadInt16();

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

   462 		{

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

   464 		aMimeInfo.AppendL(mimeInfo);

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

   466         }

   467 	}

   468 

   469 

   470 //

   471 // class CCnaConvInfoFile2

   472 //

   473 

   474 CCnaConvInfoFile2::~CCnaConvInfoFile2()

   475 	{

   476 	if (iConverters)

   477 		{

   478 		iConverters->ResetAndDestroy();

   479 		}

   480 	delete iConverters;

   481 	iResourceFile.Close();

   482 	iFs.Close();

   483 	}

   484 

   485 void CCnaConvInfoFile2::ConstructL()

   486 	{

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

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

   489 	}

   490 

   491 //

   492 // class CCnaConvInfoFileReader2

   493 //

   494 

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

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

   497 

   498 @param aFileName The .rsc file name.

   499 @return The new CCnaConvInfoFileReader2 object. */

   500 	{

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

   502 	CleanupStack::PushL(self);

   503 	self->ConstructL(aFileName);

   504 	return self;

   505 	}

   506 

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

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

   509 

   510 @param aFileName The .rsc file name.

   511 @return The new CCnaConvInfoFileReader2 object. */

   512 	{

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

   514 	CleanupStack::Pop(self); 

   515 	return self;

   516 	}

   517 

   518 CCnaConvInfoFileReader2::CCnaConvInfoFileReader2()

   519 	{

   520 	}

   521 

   522 void CCnaConvInfoFileReader2::RestoreConverterL(TResourceReader& aReader)

   523 	{

   524 	// Skip over extension

   525 	aReader.ReadUint32();

   526 	TUid converterUid;

   527 	converterUid.iUid=aReader.ReadInt32();

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

   529 	CleanupStack::PushL(tempConv);

   530 	iConverters->AppendL(tempConv);  // takes the ownership

   531 	CleanupStack::Pop(tempConv); 

   532 	}

   533 

   534 EXPORT_C void CCnaConvInfoFileReader2::RestoreL()

   535 /** Restores all the converters from the .rsc file that was specified in the NewL() or NewLC(). */

   536 	{

   537 	TResourceReader reader;

   538 	HBufC8* resource=iResourceFile.AllocReadLC(KConarcPluginResourceId); //pushes onto the cleanup stack

   539 	reader.SetBuffer(resource);

   540 	// Skip over extension

   541 	reader.ReadUint32();

   542 	const TInt numOfConverters = reader.ReadUint16();

   543 	for (TInt i = 0; i < numOfConverters; i++)

   544 		{

   545 		RestoreConverterL(reader);

   546 		}

   547 	CleanupStack::PopAndDestroy(resource);

   548 	}

   549 

   550 EXPORT_C TInt CCnaConvInfoFileReader2::Count()

   551 /** Gets the number of converters that were restored from the .rsc file. 

   552 

   553 This function returns zero if RestoreL() has not been called.

   554 

   555 @return The number of converters. */

   556 	{

   557 	if (!iConverters)

   558 		{

   559 		return 0;

   560 		}

   561 	return iConverters->Count();

   562 	}

   563 

   564 EXPORT_C CCnaConverter* CCnaConvInfoFileReader2::AtL(TInt anIndex)

   565 /** Constructs and returns a new CCnaConverter object that is a copy of the 

   566 converter at the specified index.

   567 

   568 @param anIndex An index into the object's array of converters. The array is created 

   569 by calling RestoreL(). The index must be valid, or a panic occurs.

   570 @return A copy of the converter at the specified index. The caller takes ownership. */

   571 	{

   572 	CCnaConverter* converter=CCnaConverter::NewL(*(iConverters->At(anIndex)));

   573 	return converter;

   574 	}

   575 

   576 void CCnaConvInfoFileReader2::ConstructL(const TDesC& aFileName)

   577 	{

   578 	CCnaConvInfoFile2::ConstructL();

   579 	iResourceFile.OpenL(iFs,aFileName);

   580 	}