--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/filehandling/fileconverterfw/SRC/CONCNF.CPP Tue Feb 02 10:12:00 2010 +0200
@@ -0,0 +1,580 @@
+// 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);
+ CleanupStack::PushL(tempConv);
+ iConverters->AppendL(tempConv); // takes the ownership
+ CleanupStack::Pop(tempConv);
+ }
+
+EXPORT_C void CCnaConvInfoFileReader2::RestoreL()
+/** Restores all the converters from the .rsc file that was specified in the NewL() or NewLC(). */
+ {
+ TResourceReader reader;
+ HBufC8* resource=iResourceFile.AllocReadLC(KConarcPluginResourceId); //pushes onto the cleanup stack
+ reader.SetBuffer(resource);
+ // Skip over extension
+ reader.ReadUint32();
+ const TInt numOfConverters = reader.ReadUint16();
+ for (TInt i = 0; i < numOfConverters; i++)
+ {
+ RestoreConverterL(reader);
+ }
+ CleanupStack::PopAndDestroy(resource);
+ }
+
+EXPORT_C TInt CCnaConvInfoFileReader2::Count()
+/** Gets the number of converters that were restored from the .rsc file.
+
+This function returns zero if RestoreL() has not been called.
+
+@return The number of converters. */
+ {
+ if (!iConverters)
+ {
+ return 0;
+ }
+ return iConverters->Count();
+ }
+
+EXPORT_C CCnaConverter* CCnaConvInfoFileReader2::AtL(TInt anIndex)
+/** Constructs and returns a new CCnaConverter object that is a copy of the
+converter at the specified index.
+
+@param anIndex An index into the object's array of converters. The array is created
+by calling RestoreL(). The index must be valid, or a panic occurs.
+@return A copy of the converter at the specified index. The caller takes ownership. */
+ {
+ CCnaConverter* converter=CCnaConverter::NewL(*(iConverters->At(anIndex)));
+ return converter;
+ }
+
+void CCnaConvInfoFileReader2::ConstructL(const TDesC& aFileName)
+ {
+ CCnaConvInfoFile2::ConstructL();
+ iResourceFile.OpenL(iFs,aFileName);
+ }