// 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 

 @released

 */

 EXPORT_C void CFbsBitmap::GetPixel(TRgb& aColor,const TPoint& aPoint) 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->GetPixel(aColor, aPoint, data, rasterizer);

 	if (rasterizer)

 		{

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

 		}

 	EndDataAccess(ETrue);

 	}

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

 @return The size of the bitmap, in pixels. 

 @publishedAll 

 @released

 */

 EXPORT_C TSize CFbsBitmap::SizeInPixels() const

 	{

     TSize zero;

 	if(!iHandle) return(zero);

 	return CleanAddress()->SizeInPixels();

 	}

 /** Sets the twip-size of the bitmap by converting the bitmaps pixel-size from 

 pixels to twips, using the conversion functions in the specified graphics 

 device map.

 @param aMap The graphics device map to be used for providing pixel to twip 

 conversion. 

 @publishedAll 

 @released

 */

 EXPORT_C void CFbsBitmap::SetSizeInTwips(const MGraphicsDeviceMap* aMap)

 	{

 	if (!iHandle || (iFlags & EIsRomBitmap) || aMap == NULL)

 		return;

 	TSize size=SizeInPixels();

 	size.iWidth=aMap->HorizontalPixelsToTwips(size.iWidth);

 	size.iHeight=aMap->VerticalPixelsToTwips(size.iHeight);

 	iFbs->SetCallBackPtr(&iServerHandle);

 	iFbs->CallBack();

 	// SizeInPixels() called CleanAddress() so call Address() now to make sure we don't clean the bitmap twice

 	Address()->iHeader.iSizeInTwips=size;

 	}

 /** Sets the twip-size of the bitmap directly to the specified size.

 @param aSizeInTwips The new size of the bitmap, in twips. 

 @publishedAll 

 @released

 */

 EXPORT_C void CFbsBitmap::SetSizeInTwips(const TSize& aSizeInTwips)

 	{

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

 		return;

 	iFbs->SetCallBackPtr(&iServerHandle);

 	iFbs->CallBack();

 	CleanAddress()->iHeader.iSizeInTwips = aSizeInTwips;

 	}

 /** Externalises the bitmap to the specified stream. Not supported for extended bitmaps.

 @param aStream The write stream. 

 @publishedAll 

 @released

 */

 EXPORT_C void CFbsBitmap::ExternalizeL(RWriteStream& aStream) const

 	{

 	if (!iHandle)

 		User::Leave(KErrGeneral);

 	BeginDataAccess();

 	Address()->ExternalizeL(aStream, *this);	

 	EndDataAccess(ETrue);

 	}

 /** Externalises that area of the bitmap contained within a specified 

 rectangular area. Not supported for extended bitmaps.

 @param aStream The write stream

 @param aRect The rectangular area of the bitmap to externalise. The bitmap 

 that is externalized will be of this size. 

 @publishedAll 

 @released

 */

 EXPORT_C void CFbsBitmap::ExternalizeRectangleL(RWriteStream& aStream,const TRect& aRect) const

 	{

 	if (!iHandle)

 		User::Leave(KErrGeneral);

 	BeginDataAccess();

 	Address()->ExternalizeRectangleL(aStream, aRect, *this);

 	EndDataAccess(ETrue);

 	}

 /** Internalises a CFbsBitmap from a stream.

 @param aStream The read stream.

 @publishedAll 

 @released

 */

 EXPORT_C void CFbsBitmap::InternalizeL(RReadStream& aStream)

 	{

 	if(!iFbs) User::Leave(KErrCouldNotConnect);

 	Reset();

 	SEpocBitmapHeader header;

 	CBitwiseBitmap::InternalizeHeaderL(aStream,header);

 	TDisplayMode dispmode = CBitwiseBitmap::DisplayMode(header.iBitsPerPixel,header.iColor);

 	User::LeaveIfError(Create(header.iSizeInPixels,dispmode));

 	TUint32* data;

 	CBitwiseBitmap* bmp=BeginDataAccessAndGetCleanAddress(data);

 	bmp->iHeader=header;

 	TInt bytesize = header.iBitmapSize - header.iStructSize;

 	if (bytesize > 0)

 		{

 		bmp->DoInternalizeL(aStream, bytesize, data);

 		EndDataAccess(EFalse);

 		}

 	else

 		{

 		EndDataAccess(ETrue);

 		}

 	}

 EXPORT_C TInt CFbsBitmap::Compress()

  	{

 	return Compress(ERLECompression);

 	}

 /** Compresses bitmap in RAM.

 @param aScheme specifies preferred compression type ERLECompression or EPaletteCompression

 @return KErrNone on success, KErrGeneral if the bitmap handle is NULL, KErrAccessDenied if 

 the bitmap is in ROM or it is an extended bitmap, otherwise one of the system wide error codes. 

 @publishedAll 

 @released

 */

 EXPORT_C TInt CFbsBitmap::Compress(TBitmapfileCompressionScheme aScheme)

 	{

  	if (!iHandle)

  		return KErrGeneral;

  	if (iFlags & EIsReadOnlyBitmapMask)

  		return KErrAccessDenied; 	

 	TPckgBuf<TBmpHandles> handlebuf;

 	TIpcArgs args(iHandle, aScheme, &handlebuf);

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

 	if (err != KErrNone)

 		return err;

 	iHandle = handlebuf().iHandle;

 	iServerHandle = handlebuf().iServerHandle;

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

 	return KErrNone;

 	}

 /** Submits the bitmap for asynchronous background compression.

 @param aRequestStatus The request status which will be completed with the appropriate error code after the compression has finished

 The error code will be KErrNone on success, KErrGeneral if the bitmap handle is NULL, KErrAccessDenied if the

 bitmap is in ROM or it is an extended bitmap, otherwise one of the system wide error codes.

 @publishedAll 

 @released

 */

 EXPORT_C void CFbsBitmap::CompressInBackground(TRequestStatus& aRequestStatus)

 	{

 	CompressInBackground(aRequestStatus, ERLECompression);

 	}

 /** Submits the bitmap for asynchronous background compression. No notification will be provided when the compression has completed.

 @return KErrNone if the bitmap was successfully submitted to the background compression queue, KErrGeneral if the bitmap handle is NULL, 

 KErrAccessDenied if the bitmap is in ROM or it is an extended bitmap,  otherwise another of the system-wide error codes.

 @publishedAll 

 @released

 */

 EXPORT_C TInt CFbsBitmap::CompressInBackground()

 	{

 	return CompressInBackground(ERLECompression);

 	}

 /** Submits the bitmap for asynchronous background compression.

 @param aRequestStatus The request status which will be completed with the appropriate error code after the compression has finished.

 The error code will be KErrNone on success, KErrGeneral if the bitmap handle is NULL, KErrAccessDenied if the

 bitmap is in ROM or it is an extended bitmap, otherwise one of the system wide error codes.

 @param aScheme Specifies preferred compression type: ERLECompression or EPaletteCompression

 @publishedAll 

 @released

 */

 EXPORT_C void CFbsBitmap::CompressInBackground(TRequestStatus& aRequestStatus, TBitmapfileCompressionScheme aScheme)

 	{

 	TRequestStatus* reqStat = &aRequestStatus;

 	aRequestStatus = KRequestPending;

 	if (!iHandle)

 		User::RequestComplete(reqStat, KErrGeneral);

 	else if (iFlags & EIsReadOnlyBitmapMask)

 		User::RequestComplete(reqStat, KErrAccessDenied);	

 	else

 		{

 		TIpcArgs args(iHandle, aScheme, ETrue);

 		iFbs->SendCommand(EFbsMessBitmapBgCompress, args, aRequestStatus);

 		}

 	}

 /** Submits the bitmap for asynchronous background compression. No notification will be provided when the compression has completed.

 @return KErrNone if the bitmap was successfully submitted to the background compression queue, KErrGeneral if the bitmap handle is NULL, 

 KErrAccessDenied if the bitmap is in ROM or it is an extended bitmap, otherwise another of the system-wide error codes.

 @publishedAll 

 @released

 */

 EXPORT_C TInt CFbsBitmap::CompressInBackground(TBitmapfileCompressionScheme aScheme)

 	{

 	if (!iHandle)

 		return KErrGeneral;

 	if (iFlags & EIsReadOnlyBitmapMask)

 		return KErrAccessDenied;	

 	TIpcArgs args(iHandle, aScheme, EFalse);

 	return iFbs->SendCommand(EFbsMessBitmapBgCompress, args);

 	}

 /**Tests whether the bitmap located in RAM has been compressed.

 @return ETrue if the bitmap is compressed, EFalse otherwise.

 @publishedAll

 @released

 */	

 EXPORT_C TBool CFbsBitmap::IsCompressedInRAM() const

 	{

 	CBitwiseBitmap* bitmap = CleanAddress();

 	if (bitmap==NULL)

 		{

 		return EFalse;

 		}	

 	return bitmap->IsCompressedInRAM();

 	}

 /** Gets the twip-size of the bitmap.

 @return The size of the bitmap, in twips. 

 @publishedAll 

 @released

 */

 EXPORT_C TSize CFbsBitmap::SizeInTwips() const

 	{

     TSize zero;

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

 	return CleanAddress()->SizeInTwips();

 	}

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

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

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

 @publishedAll 

 @released

 */

 EXPORT_C TInt CFbsBitmap::VerticalPixelsToTwips(TInt aPixels) const

 	{

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

 	return CleanAddress()->VerticalPixelsToTwips(aPixels);

 	}

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

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

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

 @publishedAll 

 @released

 */

 EXPORT_C TInt CFbsBitmap::VerticalTwipsToPixels(TInt aTwips) const

 	{

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

 	return CleanAddress()->VerticalTwipsToPixels(aTwips);

 	}

 /** Tests whether or not the specified file is in ROM.

 @param aFilename The name of the file. 

 @param aWord On return, contains the address of the file in ROM. 

 @return ETrue if the file is in the ROM; EFalse otherwise. 

 @publishedAll 

 @released

 */

 EXPORT_C TBool CFbsBitmap::IsFileInRom(const TDesC& aFilename,TUint32*& aWord)

 	{

 	RFbsSession* fbs=RFbsSession::GetSession();

 	__ASSERT_ALWAYS(fbs,Panic(EFbsPanicNoConnection));

 	return fbs->LookupBitmapInROM (aFilename, (TAny*&)aWord);

 	}

 /** Tests whether or not the specified file is in ROM.

 @param aFile The file handle

 @param aWord On return, contains the address of the file in ROM. 

 @return ETrue if the file is in the ROM; EFalse otherwise. 

 @publishedAll 

 @released

 */

 EXPORT_C TBool CFbsBitmap::IsFileInRom(RFile& aFile,TUint32*& aWord)

 	{

 	// cannot use rom lookup cache as filename is not available

 	// offset must be initialised to zero to indicate beginning of the file

 	aWord = 0;

 	return aFile.Seek(ESeekAddress,(TInt&)aWord)==KErrNone;

 	}

 /** Tests whether or not the bitmap is monochrome.

 Monochrome bitmaps have a display-mode of 1 bit-per-pixel.

 @return ETrue if the bitmap is monochrome; EFalse otherwise. 

 @publishedAll 

 @released

 */

 EXPORT_C TBool CFbsBitmap::IsMonochrome() const

 	{

 	if(!iHandle) return(EFalse);

 	TUint32* data;

 	CBitwiseBitmap* bmp = BeginDataAccessAndGetCleanAddress(data);

 	TBool isMonochrome = bmp->IsMonochrome(data);

 	EndDataAccess(ETrue);

 	return isMonochrome;

 	}

 /** Marks the beginning of direct access to the bitmap data.

 This function prepares the bitmap for direct access to its pixel data

 and should be used before calling DataAddress(), otherwise performance

 may be degraded on certain platforms.

 Calls to BeginDataAccess() must be coupled with subsequent calls to EndDataAccess().

 @publishedAll

 @released

 @see CFbsBitmap::DataAddress()

 @see CFbsBitmap::EndDataAccess()

 */

 EXPORT_C void CFbsBitmap::BeginDataAccess() const

 	{

     FBS_OST_VERBOSE(OstTrace1(GRAPHICS_CONTROL_FUNCTIONS, CFBSBITMAP_BEGINDATAACCESS_ENTRY, "> this=0x%08x;", (TUint)this););

 	FBS_OST_IF(!iHandle, OstTrace1(TRACE_ERROR, CFBSBITMAP_BEGINDATAACCESS_ERROR, "! this=0x%08x; !iHandle", (TUint)this););

 	if (iHandle)

 	    {

         (void)CleanAddress();	//called for side-effect to make sure bitmap reference is current. Should be low overhead.

         const_cast<CFbsBitmap*>(this)->iUseCount++;

 	    }

 	FBS_OST_VERBOSE(OstTraceExt2(GRAPHICS_CONTROL_FUNCTIONS, CFBSBITMAP_BEGINDATAACCESS_EXIT, "< this=0x%08x; iUseCount=%d;", (TUint)this, const_cast<CFbsBitmap*>(this)->iUseCount);)

 	}

 /** Marks the end of direct access to the bitmap data.

 Use this function after ending direct access to the bitmap data.

 Calls to EndDataAccess() must correspond to prior calls to BeginDataAccess().

 See BeginDataAccess() for more details.

 @param aReadOnly Whether or not the bitmap data has only been read since

                  the corresponding call to BeginDataAccess().

 @publishedAll

 @released

 @param aReadOnly True if the bitmap data had only been read.  False if the data has been modified.

 @see CFbsBitmap::BeginDataAccess()

 */

 EXPORT_C void CFbsBitmap::EndDataAccess(TBool aReadOnly) const

 	{

     FBS_OST_VERBOSE(OstTraceExt2(GRAPHICS_CONTROL_FUNCTIONS, CFBSBITMAP_ENDDATAACCESS_ENTRY, "> this=0x%08x; aReadOnly=%d;", (TUint)this, (TUint)aReadOnly);)

     FBS_OST_IF(!iHandle, OstTrace1(TRACE_ERROR, CFBSBITMAP_ENDDATAACCESS_ERROR, "! this=0x%08x; !iHandle", (TUint)this););

     if (iHandle)

         {

         const_cast<CFbsBitmap*>(this)->iUseCount--;

         if (!aReadOnly && !(iFlags & EIsReadOnlyBitmapMask))

             {

             User::LockedInc(iAddressPointer->Extra()->iTouchCount);

             }

         }

     FBS_OST_VERBOSE(OstTraceExt2(GRAPHICS_CONTROL_FUNCTIONS, CFBSBITMAP_ENDDATAACCESS_EXIT, "< this=0x%08x; iUseCount=%d;", (TUint)this, const_cast<CFbsBitmap*>(this)->iUseCount);)

 	}

 /** Locks the global bitmap heap.

 This function is deprecated, since it is no longer necessary to lock the global

 bitmap heap to prevent the pixel data from being moved in memory asynchronously,

 as the value returned by DataAddress() can now only change as a result of bitmap

 operations explicitly requested by clients of the Font and Bitmap Server.

 Calls to LockHeap() should be replaced by calls to BeginDataAccess().

 Calls to LockHeap() must be coupled with subsequent calls to CFbsBitmap::UnlockHeap().

 Code called between a LockHeap() - UnlockHeap() pair must not include any other calls to

 CFbsBitmap methods, which internally may call CFbsBitmap::LockHeap(). Also, code must

 not leave between a LockHeap() - UnlockHeap() pair.

 @note	IMPORTANT: CFbsBitmap::LockHeap() cannot be used as a means of synchronization between

 threads concurrently accessing bitmap data.

 @publishedAll 

 @deprecated

 @see CFbsBitmap::UnlockHeap()

 @see CFbsBitmap::BeginDataAccess()

 */

 EXPORT_C void CFbsBitmap::LockHeap(TBool /*aAlways*/) const

 	{

     FBS_OST(OstTrace1(GRAPHICS_CONTROL_FUNCTIONS, CFBSBITMAP_LOCKHEAP_ENTRY, "> this=0x%08x;", (TUint)this);)

 	BeginDataAccess();

 #ifdef SYMBIAN_DEBUG_FBS_LOCKHEAP

 	//These debug checks now refer to the cleaned data address

     FBS_OST_IF(!iHandle, OstTrace1(TRACE_ERROR, CFBSBITMAP_LOCKHEAP_ERROR, "! this=0x%08x; !iHandle", (TUint)this););

 	if (iHandle && !(iFlags & EIsRomBitmap)) // can't do anything with ROM bitmaps

 		{

 		TThreadId threadId = RThread().Id();

 		iFbs->iHelper->iDebugMutex.Wait();

 		if (iAddressPointer->Extra()->iLockCount++ == 0)

 			{

 			__ASSERT_ALWAYS(iAddressPointer->Extra()->iThreadId == TThreadId(KNullThreadId), Panic(EFbsPanicBadHeapLock));

 			iAddressPointer->Extra()->iThreadId = threadId;

 			}

 		else

 			__ASSERT_ALWAYS(iAddressPointer->Extra()->iThreadId == threadId, Panic(EFbsPanicBadHeapLock));

 		iFbs->iHelper->iDebugMutex.Signal();

 		}

 #endif

 	FBS_OST(OstTrace1(GRAPHICS_CONTROL_FUNCTIONS, CFBSBITMAP_LOCKHEAP_EXIT, "< this=0x%08x;", (TUint)this);)

 	}

 /** Unlocks the global heap. 

 This function is deprecated. See LockHeap() for more details.

 Calls to UnlockHeap() should be replaced by calls to EndDataAccess().

 Calls to UnlockHeap() must correspond to prior calls to LockHeap() or LockHeapLC().

 @publishedAll 

 @deprecated

 @see CFbsBitmap::LockHeap()

 @see CFbsBitmap::EndDataAccess()

 */

 EXPORT_C void CFbsBitmap::UnlockHeap(TBool /*aAlways*/) const

 	{

     FBS_OST(OstTrace1(GRAPHICS_CONTROL_FUNCTIONS, CFBSBITMAP_UNLOCKHEAP_ENTRY, "> this=0x%08x;", (TUint)this);)

     FBS_OST_IF(!iHandle, OstTrace1(TRACE_ERROR, CFBSBITMAP_UNLOCKHEAP_ERROR, "! this=0x%08x; !iHandle", (TUint)this););

 	if (iHandle)

 	    {

 #ifdef SYMBIAN_DEBUG_FBS_LOCKHEAP

 	    if (!(iFlags & EIsRomBitmap)) // can't do anything with ROM bitmaps

             {

             TThreadId threadId = RThread().Id();

             iFbs->iHelper->iDebugMutex.Wait();

             __ASSERT_ALWAYS(iAddressPointer->Extra()->iLockCount > 0, Panic(EFbsPanicBadHeapLock));

             __ASSERT_ALWAYS(iAddressPointer->Extra()->iThreadId == threadId, Panic(EFbsPanicBadHeapLock));

             if (--iAddressPointer->Extra()->iLockCount == 0)

                 iAddressPointer->Extra()->iThreadId = TThreadId(KNullThreadId);

             iFbs->iHelper->iDebugMutex.Signal();

             }

 #endif

 	    EndDataAccess();

 	    }

 	FBS_OST(OstTrace1(GRAPHICS_CONTROL_FUNCTIONS, CFBSBITMAP_UNLOCKHEAP_EXIT, "< this=0x%08x;", (TUint)this);)

 	}

 /** Locks the global bitmap heap, leaving on the clean-up stack a pointer

 to a TCleanupItem that unlocks the heap on deletion.

 Use this function instead of LockHeap() if code may leave between the

 LockHeap() - UnlockHeap() pair. Calls to LockHeapLC() must be coupled with

 subsequent calls to CFbsBitmap::UnlockHeap() or CleanupStack::PopAndDestroy().

 This function is deprecated. See CFbsBitmap::LockHeap() for more details.

 @publishedAll 

 @deprecated

 @see CFbsBitmap::LockHeap()

 */

 EXPORT_C void CFbsBitmap::LockHeapLC(TBool /*aAlways*/) const

 	{

     FBS_OST(OstTrace1(GRAPHICS_CONTROL_FUNCTIONS, CFBSBITMAP_LOCKHEAPLC_ENTRY, "> this=0x%08x;", (TUint)this);)

     LockHeap();

 	TCleanupItem cleanitem(CFbsBitmap::UnlockHeap, (TAny*)this);

 	CleanupStack::PushL(cleanitem);

 	FBS_OST(OstTrace1(GRAPHICS_CONTROL_FUNCTIONS, CFBSBITMAP_LOCKHEAPLC_EXIT, "< this=0x%08x;", (TUint)this);)

 	}

 EXPORT_C void CFbsBitmap::UnlockHeap(TAny* aFbsBitmap)

 	{

     FBS_OST(OstTrace1(GRAPHICS_CONTROL_FUNCTIONS, CFBSBITMAP_UNLOCKHEAP2_ENTRY, "> bitmap=0x%08x;", (TUint)aFbsBitmap);)

     ((CFbsBitmap*)aFbsBitmap)->UnlockHeap();

     FBS_OST(OstTrace0(GRAPHICS_CONTROL_FUNCTIONS, CFBSBITMAP_UNLOCKHEAP2_EXIT, "<");)

 	}

 /** Tests whether the bitmap is volatile.

 A bitmap becomes volatile if CFbsBitmap::DataAdress() is called without

 CFbsBitmap::BeginDataAccess() having been called before and it can become non-volatile

 again if a resizing or compression is performed.

 @internalTechnology

 @prototype

 */

 EXPORT_C TBool CFbsBitmap::IsVolatile() const

 	{

 	if (!iHandle)

 		return EFalse;

 	return CleanAddress()->iSettings.IsVolatileBitmap();

 	}

 /** Tests how many times the bitmap has been touched.

 A bitmap is touched whenever CFbsBitmap::EndDataAccess() is called with the parameter

 aReadOnly set to EFalse and also whenever a resizing or compression is performed.

 @internalTechnology

 @prototype

 @return The number of times the bitmap has been touched.

 */

 EXPORT_C TInt CFbsBitmap::TouchCount() const

 	{

 	if (!iHandle || (iFlags & EIsReadOnlyBitmapMask))

 		return 0; // A read-only bitmap can never be touched.

 	return CleanAddress()->Extra()->iTouchCount;

 	}

 /** Returns the serial number of the bitmap

 The serial number is unique to this bitmap.

 The serial number is a signed 64-bit integer, with only the positive values being assigned.

 As ROM bitmaps do not have serial numbers, the serial number will use the negative range

 of values so that ROM bitmap's serial number cannot be the same as a RAM bitmap's.

 ROM bitmap's address pointers are unique to the ROM bitmap, so the serial number will just

 be negative value of the address pointer.

 @internalTechnology

 @prototype

 @return The unique serial number for the bitmap

 */

 EXPORT_C TInt64 CFbsBitmap::SerialNumber() const

 	{

 	if (!iHandle)

 		return 0;

 	if (iFlags & EIsRomBitmap)

 		return -TInt64(reinterpret_cast<TUint32>(iAddressPointer));

 	return CleanAddress()->Extra()->iSerialNumber;

 	}

 /** Tests whether the bitmap is large.

 @return ETrue if the bitmap is large, EFalse if not. 

 @publishedAll 

 @released

 */

 EXPORT_C TBool CFbsBitmap::IsLargeBitmap() const

 	{

 	CBitwiseBitmap* bitmap = CleanAddress();

 	if (!bitmap)

 		{

 		return EFalse;

 		}

 	return bitmap->IsLargeBitmap();

 	}

 /** Returns the handle for the hardware bitmap which this CFbsBitmap is using.

 @return The handle to the hardware bitmap. The handle is NULL if it is not 

 a hardware bitmap. 

 @publishedAll 

 @released

 */

 EXPORT_C TInt CFbsBitmap::HardwareBitmapHandle() const

 	{

 	CBitwiseBitmap* bitmap = CleanAddress();

 	if (!bitmap)

 		{

 		return 0;

 		}

 	return bitmap->HardwareBitmapHandle();

 	}

 /** Gets the attributes of the bitmap's palette.

 This is not currently supported.

 @param aModifiable On return, whether or not the palette is modifiable. 

 @param aNumEntries On return, the number of entries in the palette. 

 @publishedAll 

 @released

 */

 EXPORT_C void CFbsBitmap::PaletteAttributes(TBool& aModifiable,TInt& aNumEntries) const

 	{

 	aModifiable=EFalse;

 	aNumEntries=0;

 	}

 /** Sets the bitmap's palette.

 This is not currently supported.

 @param aPalette Not used. 

 @publishedAll 

 @released

 */

 EXPORT_C void CFbsBitmap::SetPalette(CPalette* /*aPalette*/)

 	{

 	}

 /** Gets the bitmap's palette.

 This is not currently supported.

 @param aPalette Not used. 

 @return KErrNotSupported. 

 @publishedAll 

 @released

 */

 EXPORT_C TInt CFbsBitmap::GetPalette(CPalette*& /*aPalette*/) const

 	{

 	return(KErrNotSupported);

 	}

 /**

 @internalComponent

 This method loads a bitmap from an opened file handle.

 @param  aFile mbm or rsc file handle (rsc file format: header + rsc

 	data section + mbm file section).

 @param  aId Bitmap ID - should be less than mbm file bitmaps count.

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

     made available for sharing between FBSERV clients.

 @param  aFileOffset mbm file section offset into rsc file.

 @return KErrNone if successful, otherwise another

             of the system-wide error codes.

 */	

 TInt CFbsBitmap::DoLoad(RFile& aFile,TInt32 aId,TBool aShareIfLoaded,TUint aFileOffset)

 	{

 	TInt ret=KErrNone;

 	TPckgBuf<TBmpHandles> handlebuf;

 	TPckgBuf<TLoadBitmapArg> loadBitmapArg;

 	loadBitmapArg().iBitmapId = aId;

 	loadBitmapArg().iShareIfLoaded = TInt(aShareIfLoaded);

 	loadBitmapArg().iFileOffset = aFileOffset;

 	//Getting the RFs Handle(2) and RFile handle(3) into a TIpcArgs into 2nd and 3rd argument

 	TIpcArgs fileargs;

 	ret=aFile.TransferToServer(fileargs,2,3);

 	if (ret!=KErrNone)

 		return ret;	

 	fileargs.Set(0,&handlebuf);

 	fileargs.Set(1,&loadBitmapArg);

 	ret=iFbs->SendCommand(EFbsMessBitmapLoad,fileargs);

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

 	iHandle=handlebuf().iHandle;

 	iServerHandle=handlebuf().iServerHandle;

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

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

 	if (ret != KErrNone)

 		return ret;

 	return iFbs->AllocScanLineBuffer(iAddressPointer->iByteWidth+4);

 	}

 /**

 @internalComponent

 This method loads a bitmap from the mbm or rsc file specified by the filename.

 @param  aFileName mbm or rsc file name (rsc file format: header + rsc

 	data section + mbm file section).

 @param  aId Bitmap ID - should be less than mbm file bitmaps count.

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

     made available for sharing between FBSERV clients.

 @param  aFileOffset mbm file section offset into rsc file.

 @return KErrNone if successful, otherwise another

             of the system-wide error codes.

 */

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

 	{

 	TInt ret=KErrNone;

 	TPckgBuf<TBmpHandles> handlebuf;

 	TPckgBuf<TLoadBitmapArg> loadBitmapArg;

 	loadBitmapArg().iBitmapId = aId;

 	loadBitmapArg().iShareIfLoaded = TInt(aShareIfLoaded);

 	loadBitmapArg().iFileOffset = aFileOffset;

 	TIpcArgs fileargs;

 	fileargs.Set(0,&handlebuf);

 	fileargs.Set(1,&loadBitmapArg);

 	fileargs.Set(2,&aFileName);

 	ret=iFbs->SendCommand(EFbsMessBitmapLoadFast,fileargs);

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

 	iHandle=handlebuf().iHandle;

 	iServerHandle=handlebuf().iServerHandle;

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

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

 	if (ret != KErrNone)

 		return ret;

 	return iFbs->AllocScanLineBuffer(iAddressPointer->iByteWidth+4);

 	}

 /**

 @internalComponent

 This method handles very special case when the rsc file is in RAM, but it 

 contains ROM mbm file.  ROM mbm file format is different than RAM mbm file 

 format and ROM mbm file cannot be loaded into RAM using standard techniques 

 (used by CFbsBitmap::DoLoad()). We have to check it is really a ROM mbm file. 

 If it is - we have to allocate the right amount of RAM, read and copy 

 requested ROM bitmap to the allocated RAM.

 @leave KErrNotSupported if this is a RAM rsc file with ROM mbm file section, 

 	or any of the RFile related error codes.

 @param aFileName rsc file name (rsc file format: header + rsc data section + 

 	mbm file section).

 @param  aId Bitmap ID - should be less than mbm file bitmaps count.

 @param aFileOffset mbm file section offset into rsc file.

 @return EFalse - this is not a ROM mbm file. ETrue - this is a ROM mbm file 

 			and	requested by aId bitmmap is loaded.

 */	

 TBool CFbsBitmap::LoadShiftedRomBmpL(const TDesC& aFileName, TInt32 aId, TUint aFileOffset)

 	{

 	RFile mbm_file;

 	::CleanupClosePushL(mbm_file);

 	User::LeaveIfError(mbm_file.Open(iFbs->FileServer(), aFileName, EFileRead | EFileShareReadersOnly));

 	TInt pos = static_cast <TInt> (aFileOffset);

 	User::LeaveIfError(mbm_file.Seek(ESeekStart, pos));//move to the beginning of the mbm file section

 	TBuf8<sizeof(CBitwiseBitmap)> buf;

 	//Check if it is a ROM mbm file

 	User::LeaveIfError(mbm_file.Read(buf, sizeof(KMultiBitmapRomImageUid.iUid)));//Bitmap file UID - ROM or RAM

 	TInt32 mbm_uid = *(reinterpret_cast <const TInt32*> (buf.Ptr())); 

 	TBool loaded = EFalse;

 	if(mbm_uid == KMultiBitmapRomImageUid.iUid)

 		{

 		if(!KRomMBMInRamRSC)

 			{

 			User::Leave(KErrNotSupported);

 			}

 		else

 			{

 			User::LeaveIfError(mbm_file.Read(buf, sizeof(TInt32)));//Number of bitmaps

 			TInt32 bmp_cnt = *(reinterpret_cast <const TInt32*> (buf.Ptr()));  

 			if(aId >= bmp_cnt) 

 				{

 				User::Leave(KErrNotFound);

 				}

 			for(TInt i=0;i<aId;i++) //Read bitmap UIDs located before aId.

 				{

 				User::LeaveIfError(mbm_file.Read(buf, sizeof(aId)));

 				}

 			User::LeaveIfError(mbm_file.Read(buf, sizeof(TInt32)));//Read the offset of aId bitmap.

 			TInt bmp_offset = *(reinterpret_cast <const TInt32*> (buf.Ptr())) + TInt(aFileOffset); 

 			pos = static_cast <TInt> (bmp_offset);

 			User::LeaveIfError(mbm_file.Seek(ESeekStart, pos));//move the file pointer to the bitmap

 			User::LeaveIfError(mbm_file.Read(buf, sizeof(CBitwiseBitmap)));//Read CBitwiseBitmap data (without the bitmap data)

 			const CBitwiseBitmap* bmp = reinterpret_cast <const CBitwiseBitmap*> (buf.Ptr());

 			//Calculate bitmap data size, alocate enough memory for the bitmap, copy CBitwiseBitmap

 			//members first, read the bitmap data from the file, copy the data to the allocated memory,

 			//initialize iRomPointer.

 			//If sizeof(CBitwiseBitmap) != real size of CBitwiseBitmap then we could have problems,

 			//because bitmap data won't be copied at the right position.

 			TInt size = bmp->iHeader.iBitmapSize - sizeof(SEpocBitmapHeader) + sizeof(CBitwiseBitmap);

 			TUint8* bmp_mem = new (ELeave) TUint8[size];

 			//There is no need bmp_mem to be aligned, because it is a pointer to a RAM block of memory.

 			TCleanupItem cleanitem(FreeMem, bmp_mem);

 			CleanupStack::PushL(cleanitem);

 			Mem::Copy(bmp_mem, bmp, sizeof(CBitwiseBitmap));

 			TPtr8 pbmp(bmp_mem + sizeof(CBitwiseBitmap), size - sizeof(CBitwiseBitmap));

 			User::LeaveIfError(mbm_file.Read(pbmp, size - sizeof(CBitwiseBitmap)));//read the bitmap data. We've already read the CBitwiseBitmap data.

 			CleanupStack::Pop(bmp_mem);

 			iAddressPointer = reinterpret_cast<CBitwiseBitmap*>(bmp_mem);

 			iFlags = EIsRomBitmap;

 			iHandle = 1;

 			loaded = ETrue;

 			}//end of - if(!KRomMBMInRamRSC) - "else" part

 		}//end of - if(mbm_uid == KMultiBitmapRomImageUid.iUid)

 	CleanupStack::PopAndDestroy();//mbm_file

 	return loaded;

 	}

 /**

 Swaps the bitmap's width and height.

 For example, if the bitmap's size is (40, 20), the new size will be (20, 40).

 Bitmap content is not preserved.

 @publishedAll

 @released

 @return KErrNone if the call was successful, KErrGeneral if the bitmap handle is 

 invalid, KErrAccessDenied if the bitmap is in ROM, KErrNotSupported if the bitmap

 is a hardware bitmap or an extended bitmap.

 */

 EXPORT_C TInt CFbsBitmap::SwapWidthAndHeight()

 	{

 	if(!iHandle) 

 		{

 		return KErrGeneral;

 		}	

 	TUint32* data;

 	CBitwiseBitmap* bmp = BeginDataAccessAndGetCleanAddress(data);

 	// Check the new bitmap size here then decide whether to swap the bitmap on the 

 	// client side or send it to be done on the server and reallocate memory for it.

 	TInt newWidthInBytes = CBitwiseBitmap::ByteWidth(bmp->iHeader.iSizeInPixels.iHeight, bmp->iSettings.CurrentDisplayMode());

 	TInt64 hugeDataSize = TInt64(bmp->iHeader.iSizeInPixels.iWidth) * TInt64(newWidthInBytes);

 	TInt err = KErrNone;

 	// If the size of the new swapped bitmap is less than or equal its original size before the swap,

 	// then we do not need to reallocate memory. The swapping is straight forward.

 	if( I64HIGH(hugeDataSize) == 0 && I64LOW(hugeDataSize) <= TUint(bmp->iHeader.iBitmapSize - bmp->iHeader.iStructSize) )	

 		{

 		err = bmp->SwapWidthAndHeight(data);

 		// Even though used DataAddress() as read-only, need to increment touch count, so indicate that data has been written

 		EndDataAccess(EFalse);

 		}

 	// Otherwise we need to reallocate memory. We do this by using the already exisitng 

 	// Resize() function as a work around- Code Reusability!!

 	else

 		{

 		EndDataAccess(ETrue); // Used DataAddress() to read only.

 		// Resize will increase touch counter

 		err = Resize(TSize(bmp->iHeader.iSizeInPixels.iHeight, bmp->iHeader.iSizeInPixels.iWidth));

 		}

 	return err;

 	}

 /** Gets a pointer to the decompression buffer owned by this thread's FBServ session.

 @param aSize The size in bytes of the scan lines to decompress.

 @return A pointer to the decompression buffer or NULL if there is no FBServ session.

 @internalTechnology

 @released

 */

 EXPORT_C HBufC8* CFbsBitmap::GetDecompressionBuffer(TInt aSize)

 	{

 		RFbsSession* ses=RFbsSession::GetSession();

 		return ses? ses->GetDecompressionBuffer(aSize) : NULL;

 	}

 /** Gets a pointer to the rasterizer for extended bitmaps if present.

 @return A pointer to the rasterizer owned by this thread's FBServ session.

 @return NULL if the rasterizer is not present.

 @internalTechnology

 @prototype

 */

 EXPORT_C CFbsRasterizer* CFbsBitmap::Rasterizer()

 	{

 	RFbsSession* session = RFbsSession::GetSession();

 	return session ? session->iHelper->Rasterizer() : NULL;

 	}

 /** Loads a specific bitmap from an opened multi-bitmap file handle.

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

 @param aFile The handle 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(RFile& aFile,TInt32 aId/*=0*/,TBool aShareIfLoaded/*=ETrue*/)

 	{

     FBS_OST(TFullName fileName;)

     FBS_OST(aFile.FullName(fileName);)

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

 	TInt ret = Load(aFile,aId,aShareIfLoaded,0);

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

 	return ret;

 	}

 /** Loads a specific bitmap from an opened multi-bitmap file handle.

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

 @param aFile The handle 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(RFile& aFile,TInt32 aId,TBool aShareIfLoaded,TUint aFileOffset)

 	{

     TInt err = KErrNone;

     FBS_OST(TFullName fileName;)

     FBS_OST(aFile.FullName(fileName);)

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

 	if (!iFbs)

 		{

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

 		err = KErrCouldNotConnect;

 		}

 	else

 	    {

         Reset();

         TUint32* rompointer;

         IsFileInRom(aFile,rompointer);

         TBool romPointerValid;

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

         if (!romPointerValid)

             {

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

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

             }

 	    }

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

 	return err;

 	}

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

 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 aFile The handle 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(RFile& aFile,TInt32 aId/*=0*/,TBool aShareIfLoaded/*=ETrue*/)

 	{

     FBS_OST(TFullName fileName;)

     FBS_OST(aFile.FullName(fileName);)

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

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

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

     return ret;

 	}

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

 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 aFile The handle 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(RFile& aFile,TInt32 aId,TBool aShareIfLoaded,TUint aFileOffset)

 	{

     FBS_OST(TFullName fileName;)

     FBS_OST(aFile.FullName(fileName);)

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

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

 	if (err == KErrNone)

 		{

         if (!(iFlags & EIsRomBitmap))

             {

             err = Compress();

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

             }

         else

             {

             err = KErrAccessDenied;

             FBS_OST(OstTraceExt2( TRACE_ERROR, CFBSBITMAP_LOADANDCOMPRESS4_ERROR2, "! this=0x%08x; Cannot compress bitmap in ROM; iFlags=0x%08x", (TUint)this, (TUint)iFlags);)

             }

 		}

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

 	return err;

 	}

 /** Gets all the bitmap handles for all the bitmaps stored in the Font Bitmap Server. There is a limit of

 the number of bitmaps that can be retrieved defined by KMaxBitmapHandleBufferSize. If this limit has been

 reached then KErrOverflow will be returned.

 @param aBitmapIdArray returns an array of all the bitmap handles

 @return KErrNone if successful, KErrOverflow if the bitmapBuffer is not large enough to store 

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

 @capability ReadDeviceData

 @internalComponent

 @released

 */	

 EXPORT_C TInt CFbsBitmap::GetAllBitmapHandles(RArray<TInt>& aBitmapIdArray) const

 	{

 	RBuf8 bitmapBuffer;

 	TInt ret = bitmapBuffer.Create(KMaxBitmapHandleBufferSize);

 	if (ret==KErrNone)

 		{

 		TIpcArgs args(&bitmapBuffer);

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

 		if (ret==KErrNone)

 			{

 			// Convert data returned from server and place into the RArray (aBitmapIdArray)

 			aBitmapIdArray.Reset();

 			TInt* bitmapIdPtr = (TInt*)bitmapBuffer.Ptr();

 			const TInt numBitmapIds = bitmapBuffer.Size() / KNumBytesPerBitmapHandle; // Divide by number of bytes per bitmap handle to get total number of bitmap IDs

 			for (TInt count=0; count<numBitmapIds; ++count)

 				{

 				TInt bitmapId = *bitmapIdPtr++;

 				ret = aBitmapIdArray.Append(bitmapId);

 				if (ret!=KErrNone)

 					break;

 				}

 			}

 		}

 	bitmapBuffer.Close();

 	return ret;

 	}

 /**

 @internalComponent

 This method tries to load a bitmap if mbm or rsc file is in ROM.

 @param  aRomPointer the address of the file in ROM

 @param  aId a Bitmap ID which should be less than mbm file bitmaps count.

 @param  aFileOffset mbm file section offset into rsc file.

 @param  aRomPointerValid on output it is set to ETrue if aRomPointer points to a valid ROM file or EFalse otherwise.

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

 */

 TInt CFbsBitmap::DoLoadFromRom(TUint32* aRomPointer, TInt32 aId, TUint aFileOffset, TBool& aRomPointerValid)

 	{

 	aRomPointerValid = ETrue;

 	if(aRomPointer)

 		{

 		TUint8* temp = reinterpret_cast <TUint8*> (aRomPointer);

 		__ASSERT_DEBUG(!(TUint(temp) & 0x00000003),Panic(EFbsBitmapAlignment));

 		temp += aFileOffset;

 		aRomPointer = reinterpret_cast <TUint32*> (temp);

 		if(TInt32(*aRomPointer)==KMultiBitmapRomImageUid.iUid)

 			{

 			TInt numbitmaps = (TInt)*(aRomPointer+1);

 			if(aId>=numbitmaps)

 				{

 				return(KErrEof);

 				}

 			TInt offset = *(aRomPointer+aId+2);

 			iAddressPointer = (CBitwiseBitmap*)(((TUint8*)aRomPointer) + offset);

 			iFlags = EIsRomBitmap;

 			iHandle = 1;

 			return iFbs->AllocScanLineBuffer(iAddressPointer->iByteWidth + 4);

 			}

 		}

 	aRomPointerValid = EFalse;

 	return KErrNone;

 	}

 /**

 Creates an extended bitmap. Extended bitmaps are used to store immutable

 data in a platform-specific format. They cannot be used as targets of

 graphics contexts, and modification of their data via DataAddress() or

 TBitmapUtil is not supported and results in undefined behaviour up to

 and including process termination.

 Initialisation of the raw data of the new bitmap is carried out by copying 

 the data pointed to by the parameter aData.

 Read-only access to the raw data of an extended bitmap is provided by

 DataAddress() and DataSize() in conjunction with BeginDataAccess() and

 EndDataAccess().

 Extended bitmaps have a conceptual size in pixels and a conceptual

 display mode for compatibility purposes. The raw data can be independent

 of these properties.

 @param aSizeInPixels The conceptual width and height of the new bitmap in pixels.

 @param aDispMode The conceptual display mode of the new bitmap.

 @param aType The UID identifying the data format of the new bitmap. Used by the

              extended bitmap rasterizer to distinguish between different data types.

 @param aData A pointer to the raw data to be stored in the new bitmap.

 @param aDataSize The size in bytes of the raw data to be stored in the new bitmap.

 @return KErrNone if successful; KErrArgument if the width or height specified in

 aSizeInPixels is negative, aDispMode is an invalid display mode, aData is NULL,

 aDataSize is negative or zero, or aDataType is a UID reserved for OS use; KErrTooBig

 if the width or height specified in aSizeInPixels exceeds KMaxTInt/4, or aDataSize

 exceeds KMaxTInt/2; otherwise another of the system-wide error codes.

 @publishedPartner

 @prototype

 @see CFbsBitmap::DataAddress()

 @see CFbsBitmap::DataSize()

 @see CFbsBitmap::BeginDataAccess()

 @see CFbsBitmap::EndDataAccess()

 */

 EXPORT_C TInt CFbsBitmap::CreateExtendedBitmap(const TSize& aSizeInPixels, TDisplayMode aDispMode, TUid aType, const TAny* aData, TInt aDataSize)

 	{

     TInt err;

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

 	if (!aData || aDataSize == 0)

 		{

         FBS_OST(OstTrace1( TRACE_ERROR, CFBSBITMAP_CREATEEXTENDEDBITMAP_ERROR, "! this=0x%08x; (!aData || aDataSize == 0)", (TUint)this);)

 		err = KErrArgument;

 		}

 	else

 	    {

         err = DoCreate(aSizeInPixels, aDispMode, aType, aDataSize);

         if (err == KErrNone)

             {

             Mem::Copy(iFbs->iLargeBitmapChunk.Base() + iAddressPointer->iDataOffset, aData, aDataSize);

             }

 	    }

 	FBS_OST(OstTraceExt4( GRAPHICS_RESOURCE_MANAGEMENT_FUNCTIONS, CFBSBITMAP_CREATEEXTENDEDBITMAP_EXIT, "< this=0x%08x; err=%d; iH=0x%08x; iSH=0x%08x", (TUint)this, err, iHandle, iServerHandle);)

 	return err;

 	}

 /**

 Creates an extended bitmap. Extended bitmaps are used to store immutable

 data in a platform-specific format. They cannot be used as targets of

 graphics contexts, and modification of their data via DataAddress() or

 TBitmapUtil is not supported and results in undefined behaviour up to

 and including process termination.

 Initialisation of the raw data of the new bitmap is carried out by a 

 callback to the MFbsExtendedBitmapInitializer::InitExtendedBitmap() 

 function passed through the parameter aInitializer.

 Read-only access to the raw data of an extended bitmap is provided by

 DataAddress() and DataSize() in conjunction with BeginDataAccess() and

 EndDataAccess().

 Extended bitmaps have a conceptual size in pixels and a conceptual

 display mode for compatibility purposes. The raw data can be independent

 of these properties.

 @param aSizeInPixels The conceptual width and height of the new bitmap in pixels.

 @param aDispMode The conceptual display mode of the new bitmap.

 @param aType The UID identifying the data format of the new bitmap. Used by the

              extended bitmap rasterizer to distinguish between different data types.

 @param aDataSize The size in bytes of the raw data to be stored in the new bitmap.

 @param aInitializer A reference to the initializer of the raw data to be stored in the new bitmap.

 @return KErrNone if successful; KErrArgument if the width or height specified in

 aSizeInPixels is negative, aDispMode is an invalid display mode, aData is NULL,

 aDataSize is negative or zero, or aDataType is a UID reserved for OS use; KErrTooBig

 if the width or height specified in aSizeInPixels exceeds KMaxTInt/4, or aDataSize

 exceeds KMaxTInt/2; otherwise another of the system-wide error codes.

 @publishedPartner

 @prototype

 @see CFbsBitmap::DataAddress()

 @see CFbsBitmap::DataSize()

 @see CFbsBitmap::BeginDataAccess()

 @see CFbsBitmap::EndDataAccess()

 @see MFbsExtendedBitmapInitializer

 */

 EXPORT_C TInt CFbsBitmap::CreateExtendedBitmap(const TSize& aSizeInPixels, TDisplayMode aDispMode, TUid aType, TInt aDataSize, MFbsExtendedBitmapInitializer& aInitializer)

 	{

     TInt err; 

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

 	if (aDataSize == 0)

 		{

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

 		err = KErrArgument;

 		}

 	else

 	    {

         err = DoCreate(aSizeInPixels, aDispMode, aType, aDataSize);

         if (err == KErrNone)

             {

             err = aInitializer.InitExtendedBitmap(iFbs->iLargeBitmapChunk.Base() + iAddressPointer->iDataOffset, aDataSize);

             if (err != KErrNone)

                 {

                 Reset();

                 }

             }

 	    }

 	FBS_OST(OstTraceExt4( GRAPHICS_RESOURCE_MANAGEMENT_FUNCTIONS, CFBSBITMAP_CREATEEXTENDEDBITMAP2_EXIT, "< this=0x%08x; err=%d; iH=0x%08x; iSH=0x%08x", (TUint)this, err, iHandle, iServerHandle);)

 	return err;

 	}

 /**

 Gets the UID identifying the data format of an extended bitmap.

 @return The UID identifying the data format of the bitmap or

         KNullUid if the bitmap is not an extended bitmap.

 @publishedPartner

 @prototype

 */

 EXPORT_C TUid CFbsBitmap::ExtendedBitmapType() const

 	{

 	if (iHandle == 0)

 		{

 		return KNullUid;

 		}

 	TUid type = CleanAddress()->iUid;

 	if (type.iUid == KCBitwiseBitmapUid.iUid || type.iUid == KCBitwiseBitmapHardwareUid.iUid)

 		{

 		return KNullUid;

 		}

 	return type;

 	}

 /**

 Gets the size in bytes of the bitmap data.

 @return The size in bytes of the bitmap data.

 @publishedPartner

 @prototype

 */

 EXPORT_C TInt CFbsBitmap::DataSize() const

 	{

 	if (iHandle == 0)

 		{

 		return 0;

 		}

 	CBitwiseBitmap* bmp = CleanAddress();

 	return bmp->iHeader.iBitmapSize - bmp->iHeader.iStructSize;

 	}

 /**

 Gets a pointer to an extra buffer for general use owned by this thread's FBServ session.

 @param aSize The size of the buffer in bytes

 @return A pointer to the extra buffer if successful or NULL if there is no FBServ session

 @internalTechnology

 @released

 */

 EXPORT_C HBufC8* CFbsBitmap::GetExtraBuffer(TInt aSize)

 	{

 		RFbsSession* ses=RFbsSession::GetSession();

 		return ses? ses->GetExtraBuffer(aSize) : NULL;

 	}