// Copyright (c) 1995-2010 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 <s32file.h>

#include <bitmap.h>

#include <graphicsaccelerator.h>

#include <fbs.h>

#include <graphics/bitmapuid.h>

#include "fbsdefs.h"

#include "UTILS.H"

#include "fbshelper.h"

#include "fbsrasterizer.h"

#include "BitwiseBitmap.inl"

#include "FbsMessage.H"

#include "bitmapconst.h"

#include "OstTraceDefinitions.h"

#include "fbstrace.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "FBSBMPTraces.h"

#endif

const TInt KMaxPixelSize = KMaxTInt / 4; // Maximum pixel size to avoid some overflow problems

const TInt KMaxBitmapHandleBufferSize = KNumBytesPerBitmapHandle * 2000; 	// Maximum size of buffer to store all bitmap handles.

GLREF_C void Panic(TFbsPanic aPanic);

//If we have to handle RAM located file with an embedded ROM mbm file section - 

//KRomMBMInRamRSC should be ETrue.

//If it is not allowed to do that - KRomMBMInRamRSC should be EFalse.

//The same constant is defined into TDefect test app. It should be changed too.

#pragma warning(disable : 4127)   //conditional expression is constant

LOCAL_D const TBool KRomMBMInRamRSC = EFalse;

//Cleanup function used by CFbsBitmap::LoadShiftedRomBmpL(...)

LOCAL_D void FreeMem(TAny* aMem)

	{

	delete[] static_cast<TUint8*>(aMem);

	}

// Fbs style bitmap client class for font bitmap server

/** @publishedAll */

EXPORT_C CFbsBitmap::CFbsBitmap():

	CBase(),

	iFbs(RFbsSession::GetSession()),

	iAddressPointer(NULL),

	iFlags(0),

	iUseCount(0),

	iHandle(0),

	iServerHandle(0)

	{

	}

/** Destructor. Calls Reset().

@see Reset()

@publishedAll 

@released

*/

EXPORT_C CFbsBitmap::~CFbsBitmap()

	{

	Reset();

	}

/** Gets the physical length in bytes of a scanline in memory. 

This is aligned to a 4 byte (DWORD) boundary for performance reasons.

@param aLength The length of a scanline in pixels. 

@param aDispMode The display mode of the bitmap. 

@return Number of bytes in the scanline in memory. 

@publishedAll 

@released

*/

EXPORT_C TInt CFbsBitmap::ScanLineLength(TInt aLength,TDisplayMode aDispMode)

	{

	if (aDispMode == ERgb)

		return aLength * 4;

	else if (aDispMode == ENone)

		return 0;

	return CBitwiseBitmap::ByteWidth(aLength,aDispMode);

	}

/** Releases the bitmap's handle from the font and bitmap server and decrements 

its access count.

The server-side bitmap is only deleted when the access count for the bitmap 

decrements to zero. 

@publishedAll

@released

*/

EXPORT_C void CFbsBitmap::Reset()

	{

    FBS_OST(TInt ssh = (iFbs ? iFbs->ServerSessionHandle() : 0);)

    FBS_OST(OstTraceExt4( GRAPHICS_RESOURCE_MANAGEMENT_FUNCTIONS, CFBSBITMAP_RESET_ENTRY, "> this=0x%08x; iH=0x%08x; iSH=0x%08x; iSSH=0x%08x", (TUint)this, iHandle, iServerHandle, ssh );)

	if (iHandle && !(iFlags & EIsRomBitmap))

		{

		iFbs->SendCommand(EFbsMessClose, iHandle, Handle());

		iFbs->iHelper->RemoveBitmap(*this);

		}

	if (KRomMBMInRamRSC && (iFlags & EIsRomBitmap))

		{

		// If it is a ROM bitmap, we have to check, is it a ROM bitmap located

		// in RAM? If yes, then we have to deallocate the bitmap memory.

		TBool isInRom = EFalse;

		TInt ret = User::IsRomAddress(isInRom, iAddressPointer);

		if (ret == KErrNone && !isInRom)

			delete[] reinterpret_cast<TUint8*>(iAddressPointer);

		}

	iAddressPointer = NULL;

	iFlags = 0;

	iUseCount = 0;

	iHandle = 0;

	iServerHandle = 0;

	FBS_OST(OstTrace1( GRAPHICS_RESOURCE_MANAGEMENT_FUNCTIONS, CFBSBITMAP_RESET_EXIT, "< this=0x%08x", (TUint)this );)

	}

/** Tests whether or not the bitmap is read-only.

@return ETrue if the bitmap is read-only, EFalse otherwise.

@publishedAll

@released

*/

EXPORT_C TBool CFbsBitmap::IsRomBitmap() const

	{

	return (iFlags & EIsReadOnlyBitmapMask) > 0;

	}

/**  Sets the bitmap to use a bitmap image stored in ROM.

@param aRomBitmapPointer Pointer to a bitmap stored in ROM.

@param aBitmapSizeInBytes On return, indicates the size of 

the bitmap in bytes. 

@leave KErrUnknown aRomBitmapPointer is not in ROM, or has an invalid UID.

@publishedAll

@released

*/	

EXPORT_C void CFbsBitmap::SetRomBitmapL(CBitwiseBitmap* aRomBitmapPointer,TInt& aBitmapSizeInBytes)

    {

	TBool isInRom = EFalse;

	TInt ret = User::IsRomAddress(isInRom,(TAny*)aRomBitmapPointer);

	if (ret != KErrNone || !isInRom || aRomBitmapPointer->Uid() != KCBitwiseBitmapUid)

		User::Leave(KErrUnknown);

	Reset();

	iAddressPointer = aRomBitmapPointer;

	iFlags = EIsRomBitmap;

	iHandle = 1;

	User::LeaveIfError(iFbs->AllocScanLineBuffer(aRomBitmapPointer->iByteWidth + 4));

	aBitmapSizeInBytes = Align4(aRomBitmapPointer->iHeader.iBitmapSize + 28);

	}

CBitwiseBitmap* CFbsBitmap::Address() const

	{

	if (!iHandle)

		return NULL;

	return iAddressPointer;

	}

EXPORT_C CBitwiseBitmap* CFbsBitmap::CleanAddress() const

	{

	if (!iHandle)

		return NULL;

	// Don't try to clean a dirty bitmap between calls to BeginDataAccess() and EndDataAccess(), i.e. iUseCount > 0

	// ROM bitmaps can never be dirty

	if (!(iFlags & EIsReadOnlyBitmapMask) && iUseCount == 0 && iAddressPointer->iSettings.IsDirtyBitmap())

		{

		TPckgBuf<TBmpHandles> handlebuf;

		TIpcArgs args(iHandle, &handlebuf);

		if (iFbs->SendCommand(EFbsMessBitmapClean, args) == KErrNone)

			{

			const_cast<CFbsBitmap*>(this)->iHandle = handlebuf().iHandle;

			const_cast<CFbsBitmap*>(this)->iServerHandle = handlebuf().iServerHandle;

			const_cast<CFbsBitmap*>(this)->iAddressPointer = (CBitwiseBitmap*)(iFbs->HeapBase() + handlebuf().iAddressOffset);

			}

		}

	return iAddressPointer;

	}

inline CBitwiseBitmap* CFbsBitmap::BeginDataAccessAndGetCleanAddress(TUint32*& aDataAddress) const

	{

	BeginDataAccess();

	CBitwiseBitmap* bmp = Address();

	// aDataAddress should be consistent with bmp since after the call to BeginDataAccess()

	// the call to DataAddress() will not clean the bitmap again

	aDataAddress = DataAddress();

	return bmp;

	}

/** Gets the address of the first pixel in the bitmap. 

The first pixel is at the top-left. Access to the pixel data of a bitmap

should be surrounded by calls to BeginDataAccess() and EndDataAccess(),

otherwise performance may be degraded on certain platforms.

Note: Performing a Resize() or Compress() operation changes the value returned by this function.

@return The address of the first pixel of the bitmap.

@publishedAll

@released

@see CFbsBitmap::BeginDataAccess()

@see CFbsBitmap::EndDataAccess()

*/

EXPORT_C TUint32* CFbsBitmap::DataAddress() const

	{

	if(!iHandle) return(NULL);

	CBitwiseBitmap* bmp = CleanAddress();

	if (!(iFlags & EIsReadOnlyBitmapMask) && (iUseCount == 0))

		bmp->iSettings.SetVolatileBitmap();

	if(bmp->iUid.iUid==KCBitwiseBitmapHardwareUid.iUid)   // RHardwareBitmap

		{

		RHardwareBitmap hwb(bmp->iDataOffset);	// iDataOffset = handle for hardware bitmap

		TAcceleratedBitmapInfo info;

		const TInt ret = hwb.GetInfo(info);

		return ret!=KErrNone ? NULL : (reinterpret_cast<TUint32*>(info.iAddress));

		}

	if (bmp->iHeap == NULL)

		return(reinterpret_cast<TUint32*>((TUint8*)bmp+bmp->iDataOffset));

	return(reinterpret_cast<TUint32*>(iFbs->iLargeBitmapChunk.Base()+bmp->iDataOffset));

	}

/** Gets the length in bytes between scanlines in memory.

@return The length in bytes between scanlines in memory. 

@internalAll

@released

*/

EXPORT_C TInt CFbsBitmap::DataStride() const

	{

	if (!iHandle)

		{

		return 0;

		}

	CBitwiseBitmap* bmp = CleanAddress();

	if (bmp==NULL)

		{

		return 0;

		}

	return bmp->DataStride();	

	}

/** Creates a bitmap with the specified size and display mode. The bitmap is 

created on the font and bitmap server's shared heap.

@param aSizeInPixels The size of the bitmap to be created. 

@param aDispMode The display mode of the bitmap to be created. 

@return KErrNone if successful; KErrCouldNotConnect if no connection to the 

font and bitmap server could be made; KErrArgument if either the width or height specified 

in aSizeInPixels are negative or if the requested display mode is invalid; KErrTooBig 

if the requested size is too big. 

@publishedAll

@released

*/

EXPORT_C TInt CFbsBitmap::Create(const TSize& aSizeInPixels,TDisplayMode aDispMode)

	{

    FBS_OST(OstTraceExt4(GRAPHICS_RESOURCE_MANAGEMENT_FUNCTIONS, CFBSBITMAP_CREATE_ENTRY, "> this=0x%08x; w=%d; h=%d; dm=%d", (TUint)this, aSizeInPixels.iWidth, aSizeInPixels.iHeight, aDispMode); ) 

	TInt err = DoCreate(aSizeInPixels,aDispMode,KUidCFbsBitmapCreation);

    FBS_OST(TInt ssh = (iFbs ? iFbs->ServerSessionHandle() : 0);)

	FBS_OST(OstTraceExt5(GRAPHICS_RESOURCE_MANAGEMENT_FUNCTIONS, CFBSBITMAP_CREATE_EXIT, "< this=0x%08x; err=%d; iH=0x%08x; iSH=0x%08x; iSSH=0x%08x", (TUint)this, err, iHandle, iServerHandle, ssh); )

    return err;

	}

TInt CFbsBitmap::DoCreate(const TSize& aSizeInPixels, TDisplayMode aDispMode, TUid aUid, TInt aDataSize)

	{

	if(!iFbs) return(KErrCouldNotConnect);

	if (aDispMode <= ENone || aDispMode == ERgb || aDispMode >= EColorLast) return KErrArgument;

	if(aSizeInPixels.iWidth<0 || aSizeInPixels.iHeight<0) return(KErrArgument);

	if (aDataSize < 0) return KErrArgument;

	Reset();

	TBmpSpec bmpspec;

	bmpspec.iSizeInPixels=aSizeInPixels;

	bmpspec.iDispMode=aDispMode;

	bmpspec.iHandle = aUid.iUid;	// Use iHandle to pass UID

	bmpspec.iServerHandle = aDataSize;	// Use iServerHandle to pass data size

	TPckgBuf<TBmpSpec> b;

	b=bmpspec;

	TIpcArgs args(&b);

	TInt ret=iFbs->SendCommand(EFbsMessBitmapCreate,args);

	if(ret!=KErrNone) return(ret);

	iHandle=b().iHandle;

	iServerHandle=b().iServerHandle;

	iAddressPointer=(CBitwiseBitmap*)(iFbs->HeapBase()+b().iAddressOffset);

	if (aDataSize > 0) // explicitly specified data size means extended bitmap

		{

		iFlags = EIsExtendedBitmap;

		}

	ret = iFbs->iHelper->AddBitmap(*this);

	if (ret != KErrNone)

		return ret;

	return iFbs->AllocScanLineBuffer(CBitwiseBitmap::ByteWidth(aSizeInPixels.iWidth, aDispMode)+4);

	}

/** Creates a hardware bitmap with a size and display mode.

@param aSizeInPixels The bitmap's width and height in pixels.

@param aDispMode The bitmap's display mode.

@param aCreatorUid The UID of the application calling this function. This is 

used to allow segregation of the memory used for hardware bitmaps. For instance, 

if a device has video memory attached to display and graphics accelerator 

hardware, this UID is used to determine whether any video memory is pre-allocated 

for that application's use.

@return KErrNone if successful, otherwise one of the system wide error codes. 

These include KErrCouldNotConnect if no connection has been made to the font 

and bitmap server, KErrArgument if either the width or height specified in 

aSizeInPixels are negative or if the requested display mode is invalid, or KErrNotSupported 

if hardware bitmaps are not supported on the device. 

@publishedAll

@released

*/

EXPORT_C TInt CFbsBitmap::CreateHardwareBitmap(const TSize& aSizeInPixels,TDisplayMode aDispMode,TUid aCreatorUid)

	{

    FBS_OST(OstTraceExt5( GRAPHICS_RESOURCE_MANAGEMENT_FUNCTIONS, CFBSBITMAP_CREATEHARDWAREBITMAP_ENTRY, "> this=0x%08x; w=%d; h=%d; dm=%d; uid=0x%08x", (TUint)this, aSizeInPixels.iWidth, aSizeInPixels.iHeight, aDispMode, aCreatorUid.iUid);)

	TInt err = DoCreate(aSizeInPixels,aDispMode,aCreatorUid);

    FBS_OST(TInt ssh = (iFbs ? iFbs->ServerSessionHandle() : 0);)

	FBS_OST(OstTraceExt5( GRAPHICS_RESOURCE_MANAGEMENT_FUNCTIONS, CFBSBITMAP_CREATEHARDWAREBITMAP_EXIT, "< this=0x%08x; err=%d; iH=0x%08x; iSH=0x%08x; iSSH=0x%08x", (TUint)this, err, iHandle, iServerHandle, ssh);)

	return err;

	}

/** Resets the pixel-size of the bitmap.

If the new size is bigger than the old, the original bitmap is still situated 

at (0,0), but pixels outside the range of the old pixel-size are set to zero.

@param aSizeInPixels The new size of the bitmap. 

@return KErrNone if successful; KErrArgument if the new size is illegal; 

KErrGeneral if the bitmap has not yet been created; KErrAccessDenied if the 

bitmap is in ROM or is an extended bitmap; otherwise another of the system-wide error codes. 

@publishedAll

@released

*/

EXPORT_C TInt CFbsBitmap::Resize(const TSize& aSizeInPixels)

	{

	if(aSizeInPixels.iWidth<0 || aSizeInPixels.iHeight<0) 

		return(KErrArgument);

	if(aSizeInPixels.iWidth>KMaxPixelSize || aSizeInPixels.iHeight>KMaxPixelSize)

		return(KErrTooBig);	

	if(!iHandle) 

		return(KErrGeneral);

	if (iFlags & EIsReadOnlyBitmapMask)

		return(KErrAccessDenied);	

	TPckgBuf<TBmpHandles> handlebuf;

	TIpcArgs args(iHandle, aSizeInPixels.iWidth, aSizeInPixels.iHeight, &handlebuf);

	TInt err = iFbs->SendCommand(EFbsMessBitmapResize, args);

	if (err != KErrNone)

		return (err);

	iHandle = handlebuf().iHandle;

	iServerHandle = handlebuf().iServerHandle;

	iAddressPointer = (CBitwiseBitmap*)(iFbs->HeapBase() + handlebuf().iAddressOffset);

	return iFbs->AllocScanLineBuffer(CBitwiseBitmap::ByteWidth(aSizeInPixels.iWidth, DisplayMode())+4);

	}

/** Gets the display mode of the bitmap.

@return The display mode of the bitmap. 

@publishedAll

@released

*/

EXPORT_C TDisplayMode CFbsBitmap::DisplayMode() const

	{

	if(iHandle==NULL) return(ENone);

	return CleanAddress()->DisplayMode();

	}

/** Returns the display mode that was used to create the bitmap.

@return The display mode used to create the bitmap.

@publishedAll

@released

*/

EXPORT_C TDisplayMode CFbsBitmap::InitialDisplayMode() const

	{

	if(iHandle == NULL) 

		{

		return ENone;

		}

	return CleanAddress()->InitialDisplayMode();

	}

/**

Changes the display mode of the bitmap.

The requested display mode cannot be greater (in bpp value) than the initial display mode.

This method cannot leave, for instance because of an out of memory condition. No 

additional memory is allocated or leaving methods called.

The bitmap's content is preserved when converting it to the requested display mode,

but there may be some loss of quality.

@publishedAll

@released

@param aDisplayMode The requested display mode.

@return KErrArgument if the requested mode is invalid, or has a greater bpp value 

than the initial mode. KErrNotSupported if the bitmap is compressed, or is a

ROM bitmap, an extended bitmap or a hardware bitmap. KErrGeneral if the bitmap

handle is NULL. KErrNone if the method call is successful.

@see CFbsBitmap::InitialDisplayMode()

*/

EXPORT_C TInt CFbsBitmap::SetDisplayMode(TDisplayMode aDisplayMode)

	{

	if(!iHandle) 

		{

		return KErrGeneral;

		}	

	TUint32* data;

	CBitwiseBitmap* bmp = BeginDataAccessAndGetCleanAddress(data);

	TInt err = bmp->SetDisplayMode(aDisplayMode, data);

	EndDataAccess(EFalse);

	return err;

	}

/** Duplicates a bitmap.

This function does not create a copy of the bitmap. It just assigns another 

handle to the bitmap in the font and bitmap server, and sets this object's 

handle to that. If the specified bitmap is in the ROM, it just assigns a pointer 

to it.

@param aHandle The handle to an existing bitmap.

@return KErrNone if successful; KErrCouldNotConnect if no connection to the 

font and bitmap server could be made; KErrUnknown if no bitmap could be found 

with the specified handle number.

@publishedAll

@released

@see CFbsBitmap::Handle()

*/

EXPORT_C TInt CFbsBitmap::Duplicate(TInt aBitmapHandle)	

    {

    TInt ret = KErrNone;

    FBS_OST(OstTraceExt2( GRAPHICS_RESOURCE_MANAGEMENT_FUNCTIONS, CFBSBITMAP_DUPLICATE_ENTRY, "> this=0x%08x; iH=0x%08x;", (TUint)this, aBitmapHandle);)

	if(!iFbs) 

		{

		ret = KErrCouldNotConnect;

		FBS_OST(OstTrace1( TRACE_ERROR, CFBSBITMAP_DUPLICATE_ERROR, "! this=0x%08x; !iFbs", (TUint)this);)

		}

	else if(!aBitmapHandle) 

		{

		ret = KErrUnknown;

		FBS_OST(OstTrace1( TRACE_ERROR, CFBSBITMAP_DUPLICATE_ERROR2, "! this=0x%08x; !aBitmapHandle", (TUint)this);)

		}

    else

        {

        TBool isinrom = EFalse;

        ret = User::IsRomAddress(isinrom, (TAny*)aBitmapHandle);

        if (ret == KErrNone)

            {

            if (isinrom)

                {

                ret = DuplicateInRom(aBitmapHandle);

                FBS_OST_IF(ret != KErrNone, OstTraceExt2( TRACE_ERROR, CFBSBITMAP_DUPLICATE_ERROR4, "! this=0x%08x; DuplicateInRom() returned %d;", (TUint)this, ret);)

                }

            else

                {

                ret = DuplicateInRam(aBitmapHandle);

                FBS_OST_IF(ret != KErrNone, OstTraceExt2( TRACE_ERROR, CFBSBITMAP_DUPLICATE_ERROR5, "! this=0x%08x; DuplicateInRam() returned %d;", (TUint)this, ret);)

                }

            }

        else 

            {

            FBS_OST(OstTraceExt2( TRACE_ERROR, CFBSBITMAP_DUPLICATE_ERROR3, "! this=0x%08x; IsRomAddress() returned %d", (TUint)this, ret);)

            ret = KErrUnknown;

            }

        }

    FBS_OST(TInt ssh = (iFbs ? iFbs->ServerSessionHandle() : 0);)

    FBS_OST(OstTraceExt5( GRAPHICS_RESOURCE_MANAGEMENT_FUNCTIONS, CFBSBITMAP_DUPLICATE_EXIT, "< this=0x%08x; iH=0x%08x; iSH=0x%08x; ret=%d; iSSH=0x%08x", (TUint)this, iHandle, iServerHandle, ret, ssh);)

	return ret;

    }

/** Duplicates a bitmap where the bitmap handle refers to a rom bitmap.

@param aBitmapHandle A valid Rom bitmap handle.

@return KErrNone on success.

 */

TInt CFbsBitmap::DuplicateInRom(TInt aBitmapHandle)

    {

    TInt ret = KErrNone;

    Reset();

    TUid uid = ((CBitwiseBitmap*)aBitmapHandle)->Uid();

    if (uid != KCBitwiseBitmapUid)

        {

        FBS_OST(OstTraceExt2( TRACE_ERROR, CFBSBITMAP_DUPLICATEINROM_ERROR, "! this=0x%08x; 0x%08x != KCBitwiseBitmapUid", (TUint)this, (TUint)uid.iUid);)

        ret = KErrUnknown;

        }

    else

        {

        iAddressPointer = (CBitwiseBitmap*)aBitmapHandle;

        iFlags = EIsRomBitmap;

        iHandle=1;

        ret = iFbs->AllocScanLineBuffer(iAddressPointer->iByteWidth + 4);

        FBS_OST_IF(ret!=KErrNone, OstTraceExt2( TRACE_ERROR, CFBSBITMAP_DUPLICATEINROM_ERROR2, "! this=0x%08x; AllocScanLineBuffer() returned %d", (TUint)this, ret);)

        }

    return ret;

    }

/** Duplicates a bitmap where the bitmap handle refers to a ram bitmap

@param aBitmapHandle A valid Ram bitmap handle.

@return KErrNone on success.

 */

TInt CFbsBitmap::DuplicateInRam(TInt aBitmapHandle)

    {

    TInt ret = KErrNone;

    Reset();

    TPckgBuf<TBmpHandles> b;

    TIpcArgs args(aBitmapHandle,&b);

    ret=iFbs->SendCommand(EFbsMessBitmapDuplicate,args);

    FBS_OST_IF(ret!=KErrNone, OstTraceExt2( TRACE_ERROR, CFBSBITMAP_DUPLICATEINRAM_ERROR, "! this=0x%08x; SendCommand(EFbsMessBitmapDuplicate) returned %d", (TUint)this, ret);)

    if(ret==KErrNone) 

        {

        iHandle=b().iHandle;

        iServerHandle=b().iServerHandle;

        iAddressPointer=(CBitwiseBitmap*)(iFbs->HeapBase()+b().iAddressOffset);

        if (iAddressPointer->iUid.iUid != KCBitwiseBitmapUid.iUid && iAddressPointer->iUid.iUid != KCBitwiseBitmapHardwareUid.iUid)

            {

            iFlags = EIsExtendedBitmap;

            }

        ret = iFbs->iHelper->AddBitmap(*this);

        FBS_OST_IF(ret!=KErrNone, OstTraceExt2( TRACE_ERROR, CFBSBITMAP_DUPLICATEINRAM_ERROR2, "! this=0x%08x; AddBitmap() returned %d", (TUint)this, ret);)

        if (ret == KErrNone)

            {

            ret = iFbs->AllocScanLineBuffer(iAddressPointer->iByteWidth+4);

            FBS_OST_IF(ret!=KErrNone, OstTraceExt2( TRACE_ERROR, CFBSBITMAP_DUPLICATEINRAM_ERROR3, "! this=0x%08x; AllocScanLineBuffer() returned %d", (TUint)this, ret);)

            }

        }

    return ret;

    }

/** Loads a specific bitmap from a multi-bitmap file.

The bitmap may be shared by other font and bitmap server clients.

@param aFileName The filename of the multi-bitmap (.mbm) file. 

@param aId The bitmap identifier.

@param aShareIfLoaded Specifies whether or not the loaded bitmap will be made 

available for sharing between font and bitmap server clients. 

@return KErrNone if successful, otherwise another of the system error 

codes. 

@publishedAll

@released

*/	

EXPORT_C TInt CFbsBitmap::Load(const TDesC& aFileName,TInt32 aId,TBool aShareIfLoaded)

	{

    FBS_OST(OstTraceExt4( GRAPHICS_RESOURCE_MANAGEMENT_FUNCTIONS, CFBSBITMAP_LOAD_ENTRY, "> this=0x%08x; file=%S, id=0x%08x; share=%d", (TUint)this, aFileName, aId, aShareIfLoaded);)

	TInt err = Load(aFileName,aId,aShareIfLoaded,0);

    FBS_OST(OstTraceExt2( GRAPHICS_RESOURCE_MANAGEMENT_FUNCTIONS, CFBSBITMAP_LOAD_EXIT, "< this=0x%08x; err=%d", (TUint)this, err);)

	return err; 

	}

/**  Loads a specific bitmap from a multi-bitmap file.

The bitmap may be shared by other font and bitmap server clients.

@param aFileName The filename of the multi-bitmap (.mbm) file.

@param aId The bitmap identifier.

@param aShareIfLoaded  Specifies whether or not the loaded bitmap will be made 

available for sharing between FBSERV clients.

@param aFileOffset Bitmap file section offset within the file.

@return KErrNone if successful, otherwise another of the system error codes.

@publishedAll

@released

*/	

EXPORT_C TInt CFbsBitmap::Load(const TDesC& aFileName,TInt32 aId,TBool aShareIfLoaded,TUint aFileOffset)

	{

    TInt err = KErrNone;

    FBS_OST(OstTraceExt5( GRAPHICS_RESOURCE_MANAGEMENT_FUNCTIONS, CFBSBITMAP_LOAD2_ENTRY, "> this=0x%08x; file=%S, id=0x%08x; share=%d; off=%d", (TUint)this, aFileName, aId, aShareIfLoaded, aFileOffset);)

	if(!iFbs)

		{

        FBS_OST(OstTrace1( TRACE_ERROR, CFBSBITMAP_LOAD2_ERROR, "! this=0x%08x; !iFbs", (TUint)this);)

		err = KErrCouldNotConnect;

		}

	else

	    {

        Reset();

        TUint32* rompointer = NULL;

        //access using filename has the advantage of using rom address lookup cache

        IsFileInRom(aFileName, rompointer);

        TBool romPointerValid;

        err = DoLoadFromRom(rompointer, aId, aFileOffset, romPointerValid);

        if(!romPointerValid)

            {

            _LIT(KResourcePath, "?:\\Resource\\*");

            TInt match = aFileName.MatchF(KResourcePath);

            //if the file is in the resource directory we don't need to check capabilities and the file can just be opened on the server side.

            if (match == 0)

                {

                err = DoLoad(aFileName,aId,aShareIfLoaded,aFileOffset);

                FBS_OST_IF(err!=KErrNone, OstTraceExt2( TRACE_ERROR, CFBSBITMAP_LOAD2_ERROR3, "! this=0x%08x; DoLoad returned %d", (TUint)this, err);)

                }

            else

                {

                RFile file;

                err = file.Open(iFbs->FileServer(),aFileName,EFileShareReadersOnly);

                if (err==KErrNone)

                    {

                    err = DoLoad(file,aId,aShareIfLoaded,aFileOffset);

                    FBS_OST_IF(err!=KErrNone, OstTraceExt2( TRACE_ERROR, CFBSBITMAP_LOAD2_ERROR4, "! this=0x%08x; DoLoad returned %d", (TUint)this, err);)

                    }

                file.Close();

                }

            }

	    }

    FBS_OST(OstTraceExt2( GRAPHICS_RESOURCE_MANAGEMENT_FUNCTIONS, CFBSBITMAP_LOAD2_EXIT, "< this=0x%08x; err=%d", (TUint)this, err);)

	return err;

	}

/** Loads and compresses a specific bitmap from a multi-bitmap file.

The bitmap may be shared by other font and bitmap server clients.

If the bitmap is loaded from ROM then compression is not allowed.

@param aFileName The filename of the multi-bitmap (.mbm) file.

@param aId The bitmap identifier.

@param aShareIfLoaded Specifies whether or not the loaded bitmap will be

made available for sharing between FBSERV clients.

@return KErrNone if successful, otherwise another of the system-wide error 

codes. 

@publishedAll 

@released

*/	

EXPORT_C TInt CFbsBitmap::LoadAndCompress(const TDesC& aFileName,TInt32 aId,TBool aShareIfLoaded)

    {	

    FBS_OST(OstTraceExt4( GRAPHICS_RESOURCE_MANAGEMENT_FUNCTIONS, CFBSBITMAP_LOADANDCOMPRESS_ENTRY, "> this=0x%08x; file=%S; id=0x%08x; share=%d", (TUint)this, aFileName, aId, aShareIfLoaded);)

    TInt ret = LoadAndCompress(aFileName, aId, aShareIfLoaded, 0);

    FBS_OST(OstTraceExt2( GRAPHICS_RESOURCE_MANAGEMENT_FUNCTIONS, CFBSBITMAP_LOADANDCOMPRESS_EXIT, "< this=0x%08x; err=%d", (TUint)this, ret);)

    return ret;

	}

/** Loads and compresses a specific bitmap from a multi-bitmap file.

The bitmap may be shared by other font and bitmap server clients. If the 

bitmap is loaded from ROM then compression is not allowed.

@param aFileName The filename of the multi-bitmap (.mbm) file.

@param aId The bitmap identifier.

@param aShareIfLoaded Specifies whether or not the loaded bitmap will be made 

available for sharing between FBSERV clients.

@param aFileOffset Bitmap file section offset within the file.

@return KErrNone if successful, otherwise another of the system-wide error 

codes. 

@publishedAll 

@released

*/	

EXPORT_C TInt CFbsBitmap::LoadAndCompress(const TDesC& aFileName,TInt32 aId,TBool aShareIfLoaded,TUint aFileOffset)

    {

    FBS_OST(OstTraceExt5( GRAPHICS_RESOURCE_MANAGEMENT_FUNCTIONS, CFBSBITMAP_LOADANDCOMPRESS2_ENTRY, "> this=0x%08x; file=%S, id=0x%08x; share=%d; off=%d", (TUint)this, aFileName, aId, aShareIfLoaded, aFileOffset);)

	TInt err = Load(aFileName,aId,aShareIfLoaded,aFileOffset);

	if (err == KErrNone)

		{

		err = !(iFlags & EIsRomBitmap) ? Compress() : KErrAccessDenied;

		FBS_OST_IF(err!=KErrNone, OstTraceExt3( TRACE_ERROR, CFBSBITMAP_LOADANDCOMPRESS2_ERROR, "! this=0x%08x; iFlags=0x%08x; err=%d", (TUint)this, (TUint)iFlags, err);)

		}

	FBS_OST(OstTraceExt2( GRAPHICS_RESOURCE_MANAGEMENT_FUNCTIONS, CFBSBITMAP_LOADANDCOMPRESS2_EXIT, "< this=0x%08x; err=%d", (TUint)this, err);)

	return err;

	}

/** Saves the bitmap as a direct file store.

The file store overwrites any existing file with the same name.

@param aFilename The name of the file. 

@return KErrNone if successful, KErrNotSupported if this CFbsBitmap is an 

extended bitmap, otherwise another of the system-wide error codes. 

@publishedAll 

@released

*/

EXPORT_C TInt CFbsBitmap::Save(const TDesC& aFilename)

	{

	if (!iHandle)

		{

		return(KErrGeneral);

		}

	RFile file;

	TInt ret=file.Replace(iFbs->FileServer(),aFilename,EFileWrite);

	if(ret!=KErrNone) return(ret);

	TRAP(ret,DoSaveL(file));

	file.Close();

	return(ret);

	}

/** Saves the bitmap as a direct file store using an opened file handle.

The file store overwrites any existing file with the same name.

@param aFile The opened file handle

@return KErrNone if successful, KErrNotSupported if this CFbsBitmap is an 

extended bitmap, otherwise another of the system-wide error codes. 

@publishedAll 

@released

*/

EXPORT_C TInt CFbsBitmap::Save(RFile& aFile)

	{

	if (!iHandle)

		{

		return KErrGeneral;

		}

	TRAPD(ret,DoSaveL(aFile));

	return ret;

	}

void CFbsBitmap::DoSaveL(RFile& aFile)

	{

	CDirectFileStore* filestore=CDirectFileStore::NewLC(aFile); // create from open file

	TUidType uidtype(KDirectFileStoreLayoutUid,KMultiBitmapFileImageUid);

	filestore->SetTypeL(uidtype);

	RStoreWriteStream bmpstream;

	TStreamId bmpstreamid=bmpstream.CreateLC(*filestore); // create bitmap stream

	ExternalizeL(bmpstream);

	bmpstream.CommitL();

	CleanupStack::PopAndDestroy(); // bitmap stream

	RStoreWriteStream rootstream;

	TStreamId rootstreamid=rootstream.CreateLC(*filestore); // create root stream

	rootstream.WriteInt32L(1); // number of bitmaps

	rootstream<<bmpstreamid; // stream id of bitmap

	rootstream.CommitL();

	CleanupStack::PopAndDestroy(); // root stream

	filestore->SetRootL(rootstreamid);

	filestore->CommitL();

	CleanupStack::PopAndDestroy(); // file store

	}

/** Constructs a multi-bitmap file.

@param aFilename The name of the multi-bitmap file to be created.

@param aNumSources The number of bitmaps to store in the file.

@param aSources  An array of pointers to bitmaps to be stored.

@param aSourceIds An array of identifiers for the bitmaps to be stored. 

@publishedAll

@released

*/	

EXPORT_C void CFbsBitmap::StoreL(const TDesC& aFilename,TInt aNumSources,const TDesC* aSources[],TInt32 aSourceIds[])

	{

	CFbsBitmap* bitmap = new(ELeave) CFbsBitmap;

	CleanupStack::PushL(bitmap);

	CDirectFileStore* filestore = CDirectFileStore::ReplaceLC(bitmap->iFbs->FileServer(),aFilename,EFileWrite);

	DoStoreL(filestore,bitmap,aNumSources,aSources,aSourceIds);

	CleanupStack::PopAndDestroy(2,bitmap);	

	}

/** Constructs a multi-bitmap file using an opened file handle.

@param aFile The opened file handle of multi-bitmap file

@param aNumSources The number of bitmaps to store in the file.

@param aSources  An array of pointers to bitmaps to be stored.

@param aSourceIds An array of identifiers for the bitmaps to be stored. 

@publishedAll

@released

*/	

EXPORT_C void CFbsBitmap::StoreL(RFile& aFile,TInt aNumSources,const TDesC* aSources[],TInt32 aSourceIds[])

	{

	CDirectFileStore* filestore = CDirectFileStore::NewLC(aFile);

	DoStoreL(filestore,NULL,aNumSources,aSources,aSourceIds);

	CleanupStack::PopAndDestroy(filestore);	

	}

/**

@internalComponent

*/

void CFbsBitmap::DoStoreL(CDirectFileStore* aFileStore,CFbsBitmap* aBitmap,TInt aNumSources,const TDesC* aSources[],TInt32 aSourceIds[])

	{

	if(aNumSources<1 || aSources==NULL) User::Leave(KErrArgument);

	TInt count=0;

	for(;count<aNumSources;count++)

		if(aSources[count]==NULL) User::Leave(KErrArgument);

	TStreamId* ids=new(ELeave) TStreamId[aNumSources];

	CleanupArrayDeletePushL(ids);

	TInt nPushed=1;

	if (!aBitmap)

		{

		aBitmap=new(ELeave) CFbsBitmap;

		CleanupStack::PushL(aBitmap);

		++nPushed;

		}

	TUidType uidtype(KDirectFileStoreLayoutUid,KMultiBitmapFileImageUid);

	aFileStore->SetTypeL(uidtype);

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

		{

		User::LeaveIfError(aBitmap->Load(*aSources[count],aSourceIds[count]));

		RStoreWriteStream bmpstream;

		ids[count]=bmpstream.CreateLC(*aFileStore); // create bitmap stream

		aBitmap->ExternalizeL(bmpstream);

		bmpstream.Close();

		CleanupStack::Pop(); // bitmap stream

		}

	RStoreWriteStream rootstream;

	TStreamId rootstreamid=rootstream.CreateLC(*aFileStore); // create root stream

	rootstream.WriteInt32L(aNumSources); // number of bitmaps

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

		rootstream<<ids[count]; // stream ids of bitmaps

	rootstream.Close();

	CleanupStack::Pop(); // root stream

	aFileStore->SetRootL(rootstreamid);

	CleanupStack::PopAndDestroy(nPushed); // ids [and bitmap]

	}

/** Gets the bitmap's scanline for the specified line starting from the 

specified point.

The dither offset of the bitmap is taken to be TPoint(0,0).

@param aBuf The buffer in which the scanline is returned. 

@param aPoint The start pixel. 

@param aLength The number of pixels to get. 

@param aDispMode Format to be used to write the data to the buffer. 

@publishedAll

@released

*/

EXPORT_C void CFbsBitmap::GetScanLine(TDes8& aBuf,const TPoint& aPoint,TInt aLength,TDisplayMode aDispMode) const

	{

	GetScanLine(aBuf,aPoint,aLength,TPoint(0,0),aDispMode);

	}

/** Gets the bitmap's scanline for the specified line starting from the specified 

point and using the specified dither offset.

@param aBuf The buffer in which the scanline is returned. 

@param aPixel The start pixel. 

@param aLength The number of pixels to get. 

@param aDitherOffset The dither offset of the bitmap. 

@param aDispMode Format to be used to write the data to the buffer. 

@publishedAll 

@released

*/

EXPORT_C void CFbsBitmap::GetScanLine(TDes8& aBuf,const TPoint& aPoint,TInt aLength,const TPoint& aDitherOffset,TDisplayMode aDispMode) const

	{

	if(!iHandle) return;

	TUint32* data;

	CBitwiseBitmap* bmp = BeginDataAccessAndGetCleanAddress(data);

	CFbsRasterizer* rasterizer = NULL;

	if ((iFlags & EIsExtendedBitmap) && iFbs)

		{

		rasterizer = iFbs->iHelper->Rasterizer();

		if (rasterizer)

			{

			CFbsRasterizer::TBitmapDesc desc;

			desc.iSizeInPixels = bmp->SizeInPixels();

			desc.iDispMode = bmp->DisplayMode();

			desc.iDataType = bmp->iUid;

			desc.iData = data;

			desc.iDataSize = bmp->iHeader.iBitmapSize - bmp->iHeader.iStructSize;

			rasterizer->BeginBitmap(bmp->Extra()->iSerialNumber, desc, NULL);

			}

		}

	bmp->GetScanLine(aBuf, aPoint, aLength, ETrue, aDitherOffset, aDispMode, data);

	if (rasterizer)

		{

		rasterizer->EndBitmap(bmp->Extra()->iSerialNumber);

		}

	EndDataAccess(ETrue);

	}

/** Sets the bitmap's horizontal scanline at the specified y co-ordinate to the 

scanline contained in the buffer.

@param aBuf The new scanline to be written to the bitmap. 

@param aY The y co-ordinate of the scanline.

@panic FBSCLI 11 in debug builds if this is a compressed bitmap.

@panic FBSCLI 28 in debug builds if this is a read-only bitmap.

@publishedAll 

@released

*/

EXPORT_C void CFbsBitmap::SetScanLine(TDes8& aBuf,TInt aY) const

	{

	if (!iHandle)

		return;	

	if (iFlags & EIsReadOnlyBitmapMask)

		{

		__ASSERT_DEBUG(EFalse, ::Panic(EFbsPanicBitmapReadOnly));

		return;

		}

	TUint32* data;

	CBitwiseBitmap* bmp = BeginDataAccessAndGetCleanAddress(data);

	if (bmp->IsCompressed())

		{

		EndDataAccess(ETrue);

		__ASSERT_DEBUG(EFalse, ::Panic(EFbsBitmapInvalidCompression));

		return;

		}

	data = bmp->ScanLineAddress(data, aY);

	TInt bytewidth = bmp->iByteWidth;

	TInt bytelen=aBuf.Length();

	if(bytelen<bytewidth) bytewidth=bytelen;

	TInt wordlen=bytewidth>>2;

	TUint32* ptr=(TUint32*)aBuf.Ptr();

	TUint32* ptrlim=ptr+wordlen;

	while(ptr<ptrlim)

		*data++=*ptr++;

	TInt limit=wordlen<<2;

	if(limit<bytewidth)

		{

		TUint8* byteptr=(TUint8*)ptrlim;

		TUint8* databyte=(TUint8*)data;

		while(limit<bytewidth)

			{

			*databyte++=*byteptr++;

			limit++;

			}

		}

	EndDataAccess(EFalse);

	}

/** Gets the bitmap's vertical scanline starting at the specified x co-ordinate.

Note: The method only works for uncompressed bitmaps.

Note: The dither offset of the bitmap is taken to be TPoint(0,0).

@param aBuf The buffer in which the vertical scanline is returned. 

@param aX The x co-ordinate of the vertical scanline. 

@param aDispMode Format to be used to write the data to the buffer. 

@panic FBSCLI 11 in debug builds if this is not an ucompressed bitmap or an extended bitmap.

@publishedAll 

@released

*/

EXPORT_C void CFbsBitmap::GetVerticalScanLine(TDes8& aBuf,TInt aX,TDisplayMode aDispMode) const

	{

	GetVerticalScanLine(aBuf,aX,TPoint(0,0),aDispMode);

	}

/** Gets the bitmap's vertical scanline starting at the specified x co-ordinate 

and using the specified dither offset.

Note: The method only works for uncompressed bitmaps.

@param aBuf The buffer in which the vertical scanline will be returned. 

@param aX The x co-ordinate of the vertical scanline to get. 

@param aDitherOffset The dither offset of the bitmap. 

@param aDispMode Format to be used to write the data to the buffer. 

@panic FBSCLI 11 in debug builds if this is not an ucompressed bitmap or an extended bitmap.

@publishedAll 

@released

*/

EXPORT_C void CFbsBitmap::GetVerticalScanLine(TDes8& aBuf,TInt aX,const TPoint& aDitherOffset,TDisplayMode aDispMode) const

	{

	if(!iHandle) return;

	TUint32* data;

	CBitwiseBitmap* bmp = BeginDataAccessAndGetCleanAddress(data);

	CFbsRasterizer* rasterizer = NULL;

	if ((iFlags & EIsExtendedBitmap) && iFbs)

		{

		rasterizer = iFbs->iHelper->Rasterizer();

		if (rasterizer)

			{

			CFbsRasterizer::TBitmapDesc desc;

			desc.iSizeInPixels = bmp->SizeInPixels();

			desc.iDispMode = bmp->DisplayMode();

			desc.iDataType = bmp->iUid;

			desc.iData = data;

			desc.iDataSize = bmp->iHeader.iBitmapSize - bmp->iHeader.iStructSize;

			rasterizer->BeginBitmap(bmp->Extra()->iSerialNumber, desc, NULL);

			}

		}

	bmp->GetVerticalScanLine(aBuf, aX, ETrue, aDitherOffset, aDispMode, data, rasterizer);

	if (rasterizer)

		{

		rasterizer->EndBitmap(bmp->Extra()->iSerialNumber);

		}

	EndDataAccess(ETrue);

	}

/** Gets the handle number of the bitmap.

The returned value can be used to give another thread access to the bitmap.

@return The handle number of the bitmap. 

@publishedAll 

@released

@see CFbsBitmap::Duplicate()

*/

EXPORT_C TInt CFbsBitmap::Handle() const

	{

	if(!iHandle) 

		return(0);

	if (iFlags & EIsRomBitmap)

		return TInt(iAddressPointer);

	else

		return(iServerHandle);

	}

/** Creates a bitmap header.

This is used when streaming bitmaps to stores.

@return The bitmap header for the bitmap. 

@publishedAll 

@released

*/

EXPORT_C SEpocBitmapHeader CFbsBitmap::Header() const

	{

	if (iHandle)

		return CleanAddress()->iHeader;

	SEpocBitmapHeader header;

	return(header);

	}

/** Converts a horizontal dimension on the graphics device from pixels to twips.

@param aPixels A horizontal dimension on the graphics device in pixels. 

@return A horizontal dimension on the graphics device in twips. 

@publishedAll 

@released

*/

EXPORT_C TInt CFbsBitmap::HorizontalPixelsToTwips(TInt aPixels) const

	{

	if(iHandle==NULL) return(0);

	return CleanAddress()->HorizontalPixelsToTwips(aPixels);

	}

/** Converts a horizontal dimension on the graphics device from twips to pixels.

@param aTwips A horizontal dimension on the graphics device in twips. 

@return A horizontal dimension on the graphics device in pixels. 

@publishedAll 

@released

*/

EXPORT_C TInt CFbsBitmap::HorizontalTwipsToPixels(TInt aTwips) const

	{

	if(iHandle==NULL) return(0);

	return CleanAddress()->HorizontalTwipsToPixels(aTwips);

	}

/** Gets the RGB value of the specified pixel.

Note: The method only works for uncompressed bitmaps and extended bitmaps.

@param aColor On return, the RGB value of the specified pixel. 

@param aPixel The pixel whose colour is to be determined.

@panic FBSCLI 11 in debug builds if this is a compressed bitmap.

@publishedAll