// 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 <e32std.h>

#include <s32file.h>

#include <s32ucmp.h>

#include <bautils.h>

#include <barsread.h>

#include <barsc.h>

#include <barsread2.h>

#include <barsc2.h>

#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<CBitwiseBitmap*>(aRomPointer),bitmapSize);

	aRomPointer += bitmapSize;

	iMask->SetRomBitmapL(reinterpret_cast<CBitwiseBitmap*>(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<MDataSink*>(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()<aBuffer.Length())

		{

		iBuffer.ReAllocL(iBuffer.Length()+aBuffer.Length()+20);

		}

	iBuffer.Append(aBuffer);

	}

// CApaResourceFileWriterBase

CApaResourceFileWriterBase::CApaResourceFileWriterBase()

	{

	}

void CApaResourceFileWriterBase::DoGenerateFileContentsL(RBuf8& aBuffer, TUid aUid2, TUid aUid3) const

	{

	TInt mainResourceSizeInBytesWhenUncompressed=0;

	RBuf8 mainResourceInFormatContainingCompressedUnicode;

	MainResourceInCompiledFormatLC(mainResourceSizeInBytesWhenUncompressed, mainResourceInFormatContainingCompressedUnicode, ETrue);

	TInt temp=0;

	RBuf8 mainResourceInFormatNotContainingCompressedUnicode;

	MainResourceInCompiledFormatLC(temp, mainResourceInFormatNotContainingCompressedUnicode, EFalse);

	__ASSERT_DEBUG(temp==mainResourceSizeInBytesWhenUncompressed, Panic(EPanicInconsistentResourceSizeInBytes));

	TBool mainResourceInCompressedUnicodeFormat=ETrue;

	TPtrC8 mainResourceInSmallestFormat(mainResourceInFormatContainingCompressedUnicode);

	if (mainResourceInSmallestFormat.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<const TUint8*>(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<TUint8*>(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.