diff -r 000000000000 -r 2e3d3ce01487 appfw/apparchitecture/apgrfx/APGICNFL.CPP --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/appfw/apparchitecture/apgrfx/APGICNFL.CPP Tue Feb 02 10:12:00 2010 +0200 @@ -0,0 +1,928 @@ +// 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: +// apgicnfl.cpp +// + +#include +#include +#include +#include +#include +#include +#include +#include +#include "APFDEF.H" +#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS +#if !defined(__APGICNFL_PARTNER_H__) +#include "apgicnflpartner.h" +#endif +#endif //SYMBIAN_ENABLE_SPLIT_HEADERS + + +#ifdef _DEBUG +#include "APGSTD.H" // panic codes +#endif // _DEBUG + +#include "APGICNFL.H" + +// +// Try and reduce the bitmap mask depth to 1bpp (2 colours) +// +LOCAL_D CFbsBitmap* TryCompressMaskL(const CFbsBitmap& aMask) + { + CFbsBitmap* newMask=NULL; + if (aMask.DisplayMode()!=EGray2 && aMask.IsMonochrome()) + { + newMask=new(ELeave) CFbsBitmap; + CleanupStack::PushL(newMask); + const TSize size=aMask.SizeInPixels(); + User::LeaveIfError(newMask->Create(size,EGray2)); + CFbsBitmapDevice* device=CFbsBitmapDevice::NewL(newMask); + CleanupStack::PushL(device); + CFbsBitGc* gc=NULL; + User::LeaveIfError(device->CreateContext(gc)); + CleanupStack::PushL(gc); + TPoint origin(0,0); + gc->BitBlt(origin,&aMask); + CleanupStack::PopAndDestroy(2); // gc, device + CleanupStack::Pop(newMask); + } + return newMask; + } + +// +// Class CApaMaskedBitmap +// + +CApaMaskedBitmap::CApaMaskedBitmap() +:CFbsBitmap() + {} + +EXPORT_C CApaMaskedBitmap::~CApaMaskedBitmap() +/** Destructor. + +Frees resources owned by the object prior to its destruction. */ + { + delete iMask; + } + +EXPORT_C CApaMaskedBitmap* CApaMaskedBitmap::NewLC() +/** Creates a default application icon object. + +@return A pointer to the new application icon object. */ + { + CApaMaskedBitmap* self=new(ELeave) CApaMaskedBitmap; + CleanupStack::PushL(self); + self->ConstructL(); + return self; + } + +EXPORT_C CApaMaskedBitmap* CApaMaskedBitmap::NewL(const CApaMaskedBitmap* aSourceIcon) +/** Creates a new application icon object, making a duplicate copy of an existing +application icon. + +@param aSourceIcon A pointer to an existing application icon. +@return A pointer to the new application icon object. */ + { + CApaMaskedBitmap* self=new(ELeave) CApaMaskedBitmap; + CleanupStack::PushL(self); + self->ConstructL(); + User::LeaveIfError( self->iMask->Duplicate(aSourceIcon->Mask()->Handle()) ); + User::LeaveIfError( self->Duplicate(aSourceIcon->Handle()) ); + CleanupStack::Pop(self); + return self; + } + +void CApaMaskedBitmap::ConstructL() + { + if (!iFbs) + User::Leave(KErrCouldNotConnect); + + iMask=new(ELeave) CFbsBitmap; + } + +EXPORT_C CFbsBitmap* CApaMaskedBitmap::Mask() const +/** Gets the icon's mask. + +@return A pointer to the mask bitmap. */ + { + return iMask; + } + +EXPORT_C void CApaMaskedBitmap::InternalizeL(RReadStream& aStream) +/** Internalizes the application icon from the read stream. + +@param aStream The read stream. */ + { + __ASSERT_DEBUG(iMask, Panic(EPanicNullPointer)); + CFbsBitmap::InternalizeL(aStream); + aStream >> *iMask; + + // Try to reduce the colour depth of the bitmap mask + CFbsBitmap* tempMask; + tempMask = TryCompressMaskL(*iMask); + // tempMask = NULL if iMask could not be reduced + if (tempMask != NULL) + { + delete iMask; + iMask = tempMask; + } + } + +void CApaMaskedBitmap::SetRomBitmapL(TUint8* aRomPointer) + { + __ASSERT_DEBUG(iMask, Panic(EPanicNullPointer)); + TInt bitmapSize = 0; + CFbsBitmap::SetRomBitmapL(reinterpret_cast(aRomPointer),bitmapSize); + + aRomPointer += bitmapSize; + + iMask->SetRomBitmapL(reinterpret_cast(aRomPointer),bitmapSize); + } + +EXPORT_C void CApaMaskedBitmap::ExternalizeL(RWriteStream& aStream) const +/** Externalises the application icon to the specified stream. + +@param aStream The write stream. */ + { + __ASSERT_DEBUG(iMask, Panic(EPanicNullPointer)); + CFbsBitmap::ExternalizeL(aStream); + aStream << *iMask; + } + + +EXPORT_C void CApaMaskedBitmap::SetMaskBitmap(CFbsBitmap* aMask) +/** +Sets the icon's mask + +@publishedAll +@released +@param aMask A pointer to the mask bitmap +*/ + { + delete iMask; + iMask = aMask; + } + +// +// CApaResourceFileWriterBase::MDataSink +// + +void CApaResourceFileWriterBase::MDataSink::WriteBufferL(const TDesC8& aBuffer) + { + if (aBuffer.Length()>0) + { + if (iBufferSinkForCompressedUnicodeFormat!=NULL) + { + WriteInCompressedUnicodeFormatL(aBuffer.Length(), aBuffer, EFalse); + } + else + { + DoWriteBufferL(aBuffer); + iNumberOfBytesWhenUncompressed+=aBuffer.Length(); + } + } + } + +void CApaResourceFileWriterBase::MDataSink::WriteCompressedUnicodeRunL(TInt aNumberOfBytesWhenUncompressed, const TDesC8& aTextAsCompressedUnicode) + { + WriteInCompressedUnicodeFormatL(aNumberOfBytesWhenUncompressed, aTextAsCompressedUnicode, ETrue); + } + +void CApaResourceFileWriterBase::MDataSink::WriteInCompressedUnicodeFormatL(TInt aNumberOfBytesWhenUncompressed, const TDesC8& aData, TBool aCompressedUnicode) + { + __ASSERT_DEBUG(iBufferSinkForCompressedUnicodeFormat!=NULL, Panic(EPanicWrongResourceFormat1)); + const TInt dataLength=aData.Length(); + __ASSERT_DEBUG(((dataLength==0) && ((aNumberOfBytesWhenUncompressed==0) || (aNumberOfBytesWhenUncompressed==1))) || + ((dataLength>0) && (aNumberOfBytesWhenUncompressed>0)), Panic(EPanicBadCompressedUnicodeRun)); + if (dataLength>0) + { + if ((iNumberOfBytesWhenUncompressed==0) && (iBufferSinkForCompressedUnicodeFormat->iNumberOfBytesWhenUncompressed==0)) + { + if (aCompressedUnicode) + { + iFlags|=EFlag_InCompressedUnicodeRun; + } + else + { + iFlags&=~EFlag_InCompressedUnicodeRun; + } + } + else if ((iFlags&EFlag_InCompressedUnicodeRun)^(aCompressedUnicode? EFlag_InCompressedUnicodeRun: 0)) // if we're changing the state of the EFlag_InCompressedUnicodeRun flag + { + FlushL(EFalse); + iFlags^=EFlag_InCompressedUnicodeRun; // toggle the EFlag_InCompressedUnicodeRun flag + } + static_cast(iBufferSinkForCompressedUnicodeFormat)->DoWriteBufferL(aData); + } + iBufferSinkForCompressedUnicodeFormat->iNumberOfBytesWhenUncompressed+=aNumberOfBytesWhenUncompressed; + } + +TInt CApaResourceFileWriterBase::MDataSink::NumberOfBytesWhenUncompressed() const + { + TInt numberOfBytesWhenUncompressed=iNumberOfBytesWhenUncompressed; + if (iBufferSinkForCompressedUnicodeFormat!=NULL) + { + numberOfBytesWhenUncompressed+=iBufferSinkForCompressedUnicodeFormat->iNumberOfBytesWhenUncompressed; + } + return numberOfBytesWhenUncompressed; + } + +CApaResourceFileWriterBase::MDataSink::MDataSink(RBufferSink* aBufferSinkForCompressedUnicodeFormat) + :iNumberOfBytesWhenUncompressed(0), + iFlags(0), + iBufferSinkForCompressedUnicodeFormat(aBufferSinkForCompressedUnicodeFormat) + { + } + +void CApaResourceFileWriterBase::MDataSink::FlushL(TBool aFinalFlush) + { + if (iBufferSinkForCompressedUnicodeFormat!=NULL) + { + RBuf8 run; + CleanupClosePushL(run); + TInt numberOfBytesInRunWhenUncompressed=0; + iBufferSinkForCompressedUnicodeFormat->FlushAndGetAndResetL(numberOfBytesInRunWhenUncompressed, run); + if (numberOfBytesInRunWhenUncompressed>0) + { + if ((iNumberOfBytesWhenUncompressed==0) && ((iFlags&EFlag_InCompressedUnicodeRun)==0)) + { + WriteRunLengthL(0); // insert initial zero-length run-length as we're not starting with compressed Unicode + } + __ASSERT_DEBUG(run.Length()>0, Panic(EPanicBadRunLength)); + WriteRunLengthL(run.Length()); + DoWriteBufferL(run); + iNumberOfBytesWhenUncompressed+=numberOfBytesInRunWhenUncompressed; + } + CleanupStack::PopAndDestroy(&run); + if (aFinalFlush && (iNumberOfBytesWhenUncompressed==0)) + { + WriteRunLengthL(0); // write a zero-length run-length as the resource is completely empty + } + } + } + +void CApaResourceFileWriterBase::MDataSink::Reset(TInt& aNumberOfBytesWhenUncompressed) + { + aNumberOfBytesWhenUncompressed=iNumberOfBytesWhenUncompressed; + iNumberOfBytesWhenUncompressed=0; + iFlags=0; + } + +void CApaResourceFileWriterBase::MDataSink::WriteRunLengthL(TInt aRunLength) + { + __ASSERT_DEBUG((aRunLength&~0x7fff)==0, Panic(EPanicBadRunLengthParameter)); + __ASSERT_DEBUG(CompressedUnicodeFormat(), Panic(EPanicWrongResourceFormat2)); + TBuf8<2> buffer; + if (aRunLength&~0x7f) + { + buffer.Append((aRunLength>>8)|0x80); + } + buffer.Append(aRunLength&0xff); + DoWriteBufferL(buffer); // must call DoWriteBufferL here (not WriteBufferL) so that iNumberOfBytesWhenUncompressed is not altered + } + +// CApaResourceFileWriterBase::RBufferSink + +CApaResourceFileWriterBase::RBufferSink::RBufferSink(RBufferSink* aBufferSinkForCompressedUnicodeFormat) + :MDataSink(aBufferSinkForCompressedUnicodeFormat) + { + } + +void CApaResourceFileWriterBase::RBufferSink::ConstructLC() + { + iBuffer.CreateL(20); + CleanupClosePushL(*this); + } + +void CApaResourceFileWriterBase::RBufferSink::Close() + { + iBuffer.Close(); + } + +void CApaResourceFileWriterBase::RBufferSink::FlushAndGetAndResetL(TInt& aNumberOfBytesWhenUncompressed, RBuf8& aBuffer) + { + FlushL(ETrue); + iBuffer.Swap(aBuffer); + Reset(aNumberOfBytesWhenUncompressed); + } + +void CApaResourceFileWriterBase::RBufferSink::DoWriteBufferL(const TDesC8& aBuffer) + { + if (iBuffer.MaxLength()-iBuffer.Length()=mainResourceInFormatNotContainingCompressedUnicode.Length()) + { + mainResourceInCompressedUnicodeFormat=EFalse; + mainResourceInSmallestFormat.Set(mainResourceInFormatNotContainingCompressedUnicode); + } + TBool secondResourceInCompressedUnicodeFormat=EFalse; + const TDesC8* const secondResource=SecondResourceL(secondResourceInCompressedUnicodeFormat); + RBufferSink bufferSink(NULL); + bufferSink.ConstructLC(); + + WriteUidTypeL(bufferSink, aUid2, aUid3); + WriteUint8L(bufferSink, 0); // flags + WriteLittleEndianUint16L(bufferSink, (secondResource==NULL)? mainResourceSizeInBytesWhenUncompressed: Max(mainResourceSizeInBytesWhenUncompressed, secondResource->Length())); // the size in bytes of the largest resource in the file when uncompressed + TUint bitArray=0; // bit-array (one per top-level resource) indicating whether each top-level resource contains compressed unicode or not + if (mainResourceInCompressedUnicodeFormat) + { + bitArray|=0x01; + } + if (secondResourceInCompressedUnicodeFormat) + { + bitArray|=0x02; + } + WriteUint8L(bufferSink, bitArray); + WriteBufferL(bufferSink, mainResourceInSmallestFormat); + if (secondResource!=NULL) + { + WriteBufferL(bufferSink, *secondResource); + } + TInt filePosition=16+1+2+1; + WriteLittleEndianUint16L(bufferSink, filePosition); + filePosition+=mainResourceInSmallestFormat.Length(); + WriteLittleEndianUint16L(bufferSink, filePosition); + if (secondResource!=NULL) + { + filePosition+=secondResource->Length(); + WriteLittleEndianUint16L(bufferSink, filePosition); + } + TInt notUsed; + bufferSink.FlushAndGetAndResetL(notUsed, aBuffer); + + CleanupStack::PopAndDestroy(3, &mainResourceInFormatContainingCompressedUnicode); + } + +void CApaResourceFileWriterBase::WriteUidTypeL(MDataSink& aDataSink, TUid aUid2, TUid aUid3) const + { + aDataSink.WriteBufferL(TCheckedUid(TUidType(TUid::Uid(0x101f4a6b), aUid2, aUid3)).Des()); + } + +void CApaResourceFileWriterBase::WriteTextL(MDataSink& aDataSink, const TDesC& aText) const + { + // LTEXT + + WriteUint8L(aDataSink, aText.Length()); + if (!aDataSink.CompressedUnicodeFormat()) + { + if ((aDataSink.NumberOfBytesWhenUncompressed()%2)!=0) + { + WriteUint8L(aDataSink, 0xab); + } + const TInt lengthOfTextInBytes=aText.Size(); + WriteBufferL(aDataSink, TPtrC8(reinterpret_cast(aText.Ptr()), lengthOfTextInBytes)); + } + else + { + TInt numberOfBytesWhenUncompressed=aText.Size(); + if ((aDataSink.NumberOfBytesWhenUncompressed()%2)!=0) + { + ++numberOfBytesWhenUncompressed; // for the padding-byte 0xab when it's uncompressed + } + HBufC8* const textAsCompressedUnicode=AsCompressedUnicodeLC(aText); + aDataSink.WriteCompressedUnicodeRunL(numberOfBytesWhenUncompressed, *textAsCompressedUnicode); + CleanupStack::PopAndDestroy(textAsCompressedUnicode); + } + } + +void CApaResourceFileWriterBase::WriteText8L(MDataSink& aDataSink, const TDesC8& aText8) const + { + // LTEXT8 + + WriteUint8L(aDataSink, aText8.Length()); + WriteBufferL(aDataSink, aText8); + } + +void CApaResourceFileWriterBase::WriteUint8L(MDataSink& aDataSink, TUint aUint8) const + { + TBuf8<1> buffer; + buffer.Append(aUint8&0xff); + aDataSink.WriteBufferL(buffer); + } + +void CApaResourceFileWriterBase::WriteLittleEndianUint16L(MDataSink& aDataSink, TUint aUint16) const + { + TBuf8<2> buffer; + buffer.Append(aUint16&0xff); + buffer.Append((aUint16>>8)&0xff); + aDataSink.WriteBufferL(buffer); + } + +void CApaResourceFileWriterBase::WriteLittleEndianUint32L(MDataSink& aDataSink, TUint aUint32) const + { + TBuf8<4> buffer; + buffer.Append(aUint32&0xff); + buffer.Append((aUint32>>8)&0xff); + buffer.Append((aUint32>>16)&0xff); + buffer.Append((aUint32>>24)&0xff); + aDataSink.WriteBufferL(buffer); + } + +void CApaResourceFileWriterBase::WriteBufferL(MDataSink& aDataSink, const TDesC8& aBuffer) const + { + aDataSink.WriteBufferL(aBuffer); + } + +HBufC8* CApaResourceFileWriterBase::AsCompressedUnicodeLC(const TDesC& aUncompressedUnicode) + { + TUnicodeCompressor unicodeCompressor; + TMemoryUnicodeSource decompressedUnicode1(aUncompressedUnicode.Ptr()); + TMemoryUnicodeSource decompressedUnicode2(aUncompressedUnicode.Ptr()); + + // Create a buffer big enough to hold all the compressed output + TInt compressedUnicodeSizeInBytes = TUnicodeCompressor::CompressedSizeL(decompressedUnicode1, aUncompressedUnicode.Length()); + HBufC8* const compressedUnicodeBuffer=HBufC8::NewLC(compressedUnicodeSizeInBytes); + TUint8* const compressedUnicodeBuffer_asBytePointer=const_cast(compressedUnicodeBuffer->Ptr()); + + // Compress the Unicode string + TInt numberOfInputElementsConsumed = 0; + TInt numberOfOutputBytes = 0; + unicodeCompressor.CompressL(compressedUnicodeBuffer_asBytePointer, decompressedUnicode2, compressedUnicodeSizeInBytes, aUncompressedUnicode.Length(), &numberOfOutputBytes, &numberOfInputElementsConsumed); + TInt temp = 0; + unicodeCompressor.FlushL(compressedUnicodeBuffer_asBytePointer, compressedUnicodeSizeInBytes, temp); + numberOfOutputBytes+=temp; + TPtr8 compressedUnicodeBuffer_asWritable(compressedUnicodeBuffer->Des()); + compressedUnicodeBuffer_asWritable.SetLength(numberOfOutputBytes); + return compressedUnicodeBuffer; + } + +void CApaResourceFileWriterBase::MainResourceInCompiledFormatLC(TInt& aMainResourceSizeInBytesWhenUncompressed, RBuf8& aBuffer, TBool aCompressedUnicodeFormat) const + { + CleanupClosePushL(aBuffer); + RBufferSink bufferSinkForCompressedUnicodeFormat(NULL); + if (aCompressedUnicodeFormat) + { + bufferSinkForCompressedUnicodeFormat.ConstructLC(); + } + RBufferSink bufferSink(aCompressedUnicodeFormat? &bufferSinkForCompressedUnicodeFormat: NULL); + bufferSink.ConstructLC(); + MainResourceInCompiledFormatL(bufferSink); + bufferSink.FlushAndGetAndResetL(aMainResourceSizeInBytesWhenUncompressed, aBuffer); + CleanupStack::PopAndDestroy(&bufferSink); + if (aCompressedUnicodeFormat) + { + CleanupStack::PopAndDestroy(&bufferSinkForCompressedUnicodeFormat); + } + } + +// CApaRegistrationResourceFileWriter + +/** +Creates a new CApaRegistrationResourceFileWriter instance. + +@param aAppUid The UID of the application. +@param aAppFile The name and extension of the file to generate. +@param aAttributes The attributes of the application. See the TApaAppCapability class for more details. +@return A pointer to the new CApaRegistrationResourceFileWriter instance. + +@publishedPartner +@released +*/ +EXPORT_C CApaRegistrationResourceFileWriter* CApaRegistrationResourceFileWriter::NewL(TUid aAppUid, const TDesC& aAppFile, TUint aAttributes) +// aAppFile does not need to have the drive set + { // static + CApaRegistrationResourceFileWriter* const self=new(ELeave) CApaRegistrationResourceFileWriter(aAppUid, aAttributes); + CleanupStack::PushL(self); + self->ConstructL(aAppFile); + CleanupStack::Pop(self); + return self; + } + +/** +The destructor for the CApaRegistrationResourceFileWriter class. + +@publishedPartner +@released +*/ +EXPORT_C CApaRegistrationResourceFileWriter::~CApaRegistrationResourceFileWriter() + { + delete iAppFile; + delete iLocalisableResourceFile; + delete iGroupName; + delete iOpaqueData; + + TInt i; + for (i=iDataTypeList.Count()-1; i>=0; --i) + { + delete iDataTypeList[i].iType; + } + iDataTypeList.Close(); + + for (i=iFileOwnershipList.Count()-1; i>=0; --i) + { + delete iFileOwnershipList[i].iFileName; + } + iFileOwnershipList.Close(); + } + +TUid CApaRegistrationResourceFileWriter::AppUid() const +/** @internalComponent */ + { + return iAppUid; + } + +const TUid KUidAppRegistrationFile ={0x101F8021}; + +void CApaRegistrationResourceFileWriter::GenerateFileContentsL(RBuf8& aBuffer) const +/** @internalComponent */ + { + DoGenerateFileContentsL(aBuffer, KUidAppRegistrationFile, iAppUid); + } + +void CApaRegistrationResourceFileWriter::SetLocalisableResourceFileL(const TDesC& aLocalisableResourceFile) +/** @internalComponent */ + { + HBufC* const localisableResourceFile=aLocalisableResourceFile.AllocL(); + delete iLocalisableResourceFile; + iLocalisableResourceFile=localisableResourceFile; + } + +/** +Sets or clears the hidden attribute. The usual purpose of the hidden attribute is to +decide if the application should appear in the task list or not but this could vary between +products. + +@param aAppIsHidden The value of the hidden flag. + +@publishedPartner +@released +*/ +EXPORT_C void CApaRegistrationResourceFileWriter::SetAppIsHiddenL(TBool aAppIsHidden) + { + iAppIsHidden=aAppIsHidden? 1: 0; + } + +/** +Sets the embeddability attribute. See the TApaAppCapability::TEmbeddability class for more details. + +@param aEmbeddability The value of the embeddability flags. + +@publishedPartner +@released +*/ +EXPORT_C void CApaRegistrationResourceFileWriter::SetEmbeddabilityL(TApaAppCapability::TEmbeddability aEmbeddability) + { + iEmbeddability=aEmbeddability; + } + +/** +Specifies if the application supports the creation of a new file or not. + +@param aSupportsNewFile ETrue to specify that the application supports the creation of a new file. + +@publishedPartner +@released +*/ +EXPORT_C void CApaRegistrationResourceFileWriter::SetSupportsNewFileL(TBool aSupportsNewFile) + { + iSupportsNewFile=aSupportsNewFile? 1: 0; + } + +/** +Specifies if the application must be launched in the background. + +@param aLaunchInBackground ETrue if the application must be launched in the background, EFalse otherwise. + +@publishedPartner +@released +*/ +EXPORT_C void CApaRegistrationResourceFileWriter::SetLaunchInBackgroundL(TBool aLaunchInBackground) + { + iLaunchInBackground=aLaunchInBackground; + } + +/** +Sets the name of the application group. + +@param aGroupName The name of the application group. + +@publishedPartner +@released +*/ +EXPORT_C void CApaRegistrationResourceFileWriter::SetGroupNameL(const TDesC& aGroupName) + { + HBufC* const groupName=aGroupName.AllocL(); + delete iGroupName; + iGroupName=groupName; + } + +/** +Sets the default screen number. This can be used to specify the preferred screen on devices +that support more than one screen. + +@param aDefaultScreenNumber The name of the default screen. + +@publishedPartner +@released +*/ +EXPORT_C void CApaRegistrationResourceFileWriter::SetDefaultScreenNumberL(TInt aDefaultScreenNumber) + { + iDefaultScreenNumber=aDefaultScreenNumber; + } + +/** +Sets the opaque data. The opaque data is some data that is specific to the type of application. + +@publishedPartner +@released +*/ +EXPORT_C void CApaRegistrationResourceFileWriter::SetOpaqueDataL(const TDesC8& aOpaqueData) + { + HBufC8* const opaqueData=aOpaqueData.AllocL(); + delete iOpaqueData; + iOpaqueData=opaqueData; + } + +/** +Adds a datatype to the list of datatypes that the application can handle. + +@param aPriority The priority. +@param aType The datatype. + +@publishedPartner +@released +*/ +EXPORT_C void CApaRegistrationResourceFileWriter::AddDataTypeL(TInt aPriority, const TDesC8& aType) + { + SDataType dataType; + dataType.iPriority=aPriority; + dataType.iType=aType.AllocLC(); + iDataTypeList.AppendL(dataType); + CleanupStack::Pop(dataType.iType); + } + +/** +Adds a file to the list of files owned by the CApaRegistrationResourceFileWriter instances. These files +are deleted if an error occurs whil registering the new applications. + +@param aFileName The name of the file. + +@publishedPartner +@released +*/ +EXPORT_C void CApaRegistrationResourceFileWriter::AddFileOwnershipInfoL(const TDesC& aFileName) + { + SFileOwnershipInfo fileOwnershipInfo; + fileOwnershipInfo.iFileName=aFileName.AllocLC(); + iFileOwnershipList.AppendL(fileOwnershipInfo); + CleanupStack::Pop(fileOwnershipInfo.iFileName); + } + +CApaRegistrationResourceFileWriter::CApaRegistrationResourceFileWriter(TUid aAppUid, TUint aAttributes) + :iAppUid(aAppUid), + iAppFile(NULL), + iAttributes(aAttributes), + iLocalisableResourceFile(NULL), + iAppIsHidden(0), + iEmbeddability(TApaAppCapability::ENotEmbeddable), + iSupportsNewFile(0), + iLaunchInBackground(0), + iGroupName(NULL), + iDefaultScreenNumber(0), + iOpaqueData(NULL) + { + } + +void CApaRegistrationResourceFileWriter::ConstructL(const TDesC& aAppFile) + { + iAppFile=aAppFile.AllocL(); + iLocalisableResourceFile=NULL; + } + +void CApaRegistrationResourceFileWriter::WriteDataTypeL(MDataSink& aDataSink, const SDataType& aDataType) const + { + // DATATYPE + + // LONG priority + WriteLittleEndianUint32L(aDataSink, aDataType.iPriority); + + // LTEXT8 type(KMaxDataTypeLength) + WriteText8L(aDataSink, *aDataType.iType); + } + +void CApaRegistrationResourceFileWriter::WriteFileOwnershipInfoL(MDataSink& aDataSink, const SFileOwnershipInfo& aFileOwnershipInfo) const + { + // FILE_OWNERSHIP_INFO + + // LTEXT file_name(KMaxFileNameLength) + WriteTextL(aDataSink, *aFileOwnershipInfo.iFileName); + } + +void CApaRegistrationResourceFileWriter::MainResourceInCompiledFormatL(MDataSink& aDataSink) const + { + // APP_REGISTRATION_INFO + + // LONG reserved_long = 0 + WriteLittleEndianUint32L(aDataSink, 0); + + // LLINK reserved_llink = 0 + WriteLittleEndianUint32L(aDataSink, 0); + __ASSERT_DEBUG(iAppFile, Panic(EPanicNullPointer)); + // LTEXT app_file(KMaxFileNameLength) = "" + WriteTextL(aDataSink, *iAppFile); + + // LONG attributes = 0 + WriteLittleEndianUint32L(aDataSink, iAttributes); + + // LTEXT localisable_resource_file(KMaxFileNameLength) = "" + TPtrC localisableResourceFile(KNullDesC); + if (iLocalisableResourceFile!=NULL) + { + localisableResourceFile.Set(*iLocalisableResourceFile); + } + WriteTextL(aDataSink, localisableResourceFile); + + // LONG localisable_resource_id = 1 + WriteLittleEndianUint32L(aDataSink, 1); + + // BYTE hidden = KAppNotHidden + WriteUint8L(aDataSink, iAppIsHidden); + + // BYTE embeddability = KAppNotEmbeddable + WriteUint8L(aDataSink, iEmbeddability); + + // BYTE newfile = KAppDoesNotSupportNewFile + WriteUint8L(aDataSink, iSupportsNewFile); + + // BYTE launch = KAppLaunchInForeground + WriteUint8L(aDataSink, iLaunchInBackground); + + // LTEXT group_name(KAppMaxGroupName) = "" + TPtrC groupName(KNullDesC); + if (iGroupName!=NULL) + { + groupName.Set(*iGroupName); + } + WriteTextL(aDataSink, groupName); + + // BYTE default_screen_number = 0 + WriteUint8L(aDataSink, iDefaultScreenNumber); + + // LEN WORD STRUCT datatype_list[] + TInt i; + const TInt numberOfDataTypes=iDataTypeList.Count(); + WriteLittleEndianUint16L(aDataSink, numberOfDataTypes); + for (i=0; iConstructL(aShortCaption, aCaption, aGroupName); + CleanupStack::Pop(self); + return self; + } + +EXPORT_C CApaLocalisableResourceFileWriter::~CApaLocalisableResourceFileWriter() + { + delete iShortCaption; + delete iCaptionAndIcon.iCaption; + delete iCaptionAndIcon.iIconFile; + delete iGroupName; + } + +void CApaLocalisableResourceFileWriter::GenerateFileContentsL(RBuf8& aBuffer) const +/** @internalComponent */ + { + DoGenerateFileContentsL(aBuffer, TUid::Null(), TUid::Null()); + } + +void CApaLocalisableResourceFileWriter::SetIconFileL(const TDesC& aIconFile) +/** @internalComponent */ + { + HBufC* const iconFile=aIconFile.AllocL(); + delete iCaptionAndIcon.iIconFile; + iCaptionAndIcon.iIconFile=iconFile; + } + +CApaLocalisableResourceFileWriter::CApaLocalisableResourceFileWriter(TInt aNumberOfIcons) + :iShortCaption(NULL), + iGroupName(NULL) + { + iCaptionAndIcon.iCaption=NULL; + iCaptionAndIcon.iNumberOfIcons=aNumberOfIcons; + iCaptionAndIcon.iIconFile=NULL; + } + +void CApaLocalisableResourceFileWriter::ConstructL(const TDesC& aShortCaption, const TDesC& aCaption, const TDesC& aGroupName) + { + iShortCaption=aShortCaption.AllocL(); + iCaptionAndIcon.iCaption=aCaption.AllocL(); + iCaptionAndIcon.iIconFile=NULL; + iGroupName=aGroupName.AllocL(); + } + +void CApaLocalisableResourceFileWriter::WriteCaptionAndIconInfoL(MDataSink& aDataSink, const SCaptionAndIconInfo& aCaptionAndIcon) const + { + // CAPTION_AND_ICON_INFO + + // LONG reserved_long = 0 + WriteLittleEndianUint32L(aDataSink, 0); + + // LLINK reserved_llink = 0 + WriteLittleEndianUint32L(aDataSink, 0); + + // LTEXT caption(KMaxCaption) = "" + WriteTextL(aDataSink, *aCaptionAndIcon.iCaption); + + // WORD number_of_icons = 0 + WriteLittleEndianUint16L(aDataSink, aCaptionAndIcon.iNumberOfIcons); + + // LTEXT icon_file(KMaxFileNameLength) = "" + TPtrC iconFile(KNullDesC); + if (aCaptionAndIcon.iIconFile!=NULL) + { + iconFile.Set(*aCaptionAndIcon.iIconFile); + } + WriteTextL(aDataSink, iconFile); + } + +void CApaLocalisableResourceFileWriter::MainResourceInCompiledFormatL(MDataSink& aDataSink) const + { + // LOCALISABLE_APP_INFO + + // LONG reserved_long = 0 + WriteLittleEndianUint32L(aDataSink, 0); + + // LLINK reserved_llink = 0 + WriteLittleEndianUint32L(aDataSink, 0); + __ASSERT_DEBUG(iShortCaption, Panic(EPanicNullPointer)); + // LTEXT short_caption(KMaxCaption) = "" + WriteTextL(aDataSink, *iShortCaption); + + // STRUCT caption_and_icon + WriteCaptionAndIconInfoL(aDataSink, iCaptionAndIcon); + + // LEN WORD STRUCT view_list[] + WriteLittleEndianUint16L(aDataSink, 0); + __ASSERT_DEBUG(iGroupName, Panic(EPanicNullPointer)); + // LTEXT group_name(KAppMaxGroupName) = "" + WriteTextL(aDataSink, *iGroupName); + } + +const TDesC8* CApaLocalisableResourceFileWriter::SecondResourceL(TBool& aSecondResourceInCompressedUnicodeFormat) const + { + aSecondResourceInCompressedUnicodeFormat=EFalse; + return NULL; + } +