1 // Copyright (c) 1995-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 #include <s32file.h>

    17 #include <bitmap.h>

    18 #include <graphicsaccelerator.h>

    19 #include <fbs.h>

    20 #include <graphics/bitmapuid.h>

    21 #include "fbsdefs.h"

    22 #include "UTILS.H"

    23 #include "fbshelper.h"

    24 #include "fbsrasterizer.h"

    25 #include "BitwiseBitmap.inl"

    26 #include "fbsmessage.h"

    27 #include "bitmapconst.h"

    28 

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

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

    31 

    32 GLREF_C void Panic(TFbsPanic aPanic);

    33 

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

    35 //KRomMBMInRamRSC should be ETrue.

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

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

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

    39 LOCAL_D const TBool KRomMBMInRamRSC = EFalse;

    40 

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

    42 LOCAL_D void FreeMem(TAny* aMem)

    43 	{

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

    45 	}

    46 

    47 // Fbs style bitmap client class for font bitmap server

    48 /** @publishedAll */

    49 EXPORT_C CFbsBitmap::CFbsBitmap():

    50 	CBase(),

    51 	iFbs(RFbsSession::GetSession()),

    52 	iAddressPointer(NULL),

    53 	iFlags(0),

    54 	iUseCount(0),

    55 	iHandle(0),

    56 	iServerHandle(0)

    57 	{

    58 	}

    59 	

    60 /** Destructor. Calls Reset().

    61 @see Reset()

    62 @publishedAll 

    63 @released

    64 */

    65 EXPORT_C CFbsBitmap::~CFbsBitmap()

    66 	{

    67 	Reset();

    68 	}

    69 	

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

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

    72 

    73 @param aLength The length of a scanline in pixels. 

    74 @param aDispMode The display mode of the bitmap. 

    75 @return Number of bytes in the scanline in memory. 

    76 @publishedAll 

    77 @released

    78 */

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

    80 	{

    81 	if (aDispMode == ERgb)

    82 		return aLength * 4;

    83 	else if (aDispMode == ENone)

    84 		return 0;

    85 

    86 	return CBitwiseBitmap::ByteWidth(aLength,aDispMode);

    87 	}

    88 

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

    90 its access count.

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

    92 decrements to zero. 

    93 @publishedAll

    94 @released

    95 */

    96 EXPORT_C void CFbsBitmap::Reset()

    97 	{

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

    99 		{

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

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

   102 		}

   103 	if (KRomMBMInRamRSC && (iFlags & EIsRomBitmap))

   104 		{

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

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

   107 		TBool isInRom = EFalse;

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

   109 		if (ret == KErrNone && !isInRom)

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

   111 		}

   112 	iAddressPointer = NULL;

   113 	iFlags = 0;

   114 	iUseCount = 0;

   115 	iHandle = 0;

   116 	iServerHandle = 0;

   117 	}

   118 	

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

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

   121 @publishedAll

   122 @released

   123 */

   124 EXPORT_C TBool CFbsBitmap::IsRomBitmap() const

   125 	{

   126 	return (iFlags & EIsReadOnlyBitmapMask) > 0;

   127 	}

   128 

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

   130 @param aRomBitmapPointer Pointer to a bitmap stored in ROM.

   131 @param aBitmapSizeInBytes On return, indicates the size of 

   132 the bitmap in bytes. 

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

   134 @publishedAll

   135 @released

   136 */	

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

   138     {

   139 	TBool isInRom = EFalse;

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

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

   142 		User::Leave(KErrUnknown);

   143 

   144 	Reset();

   145 	iAddressPointer = aRomBitmapPointer;

   146 	iFlags = EIsRomBitmap;

   147 	iHandle = 1;

   148 

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

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

   151 	}

   152 

   153 CBitwiseBitmap* CFbsBitmap::Address() const

   154 	{

   155 	if (!iHandle)

   156 		return NULL;

   157 	return iAddressPointer;

   158 	}

   159 

   160 EXPORT_C CBitwiseBitmap* CFbsBitmap::CleanAddress() const

   161 	{

   162 	if (!iHandle)

   163 		return NULL;

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

   165 	// ROM bitmaps can never be dirty

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

   167 		{

   168 		TPckgBuf<TBmpHandles> handlebuf;

   169 		TIpcArgs args(iHandle, &handlebuf);

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

   171 			{

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

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

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

   175 			}

   176 		}

   177 	return iAddressPointer;

   178 	}

   179 

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

   181 	{

   182 	BeginDataAccess();

   183 	CBitwiseBitmap* bmp = Address();

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

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

   186 	aDataAddress = DataAddress();

   187 	return bmp;

   188 	}

   189 

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

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

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

   193 otherwise performance may be degraded on certain platforms.

   194 

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

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

   197 @publishedAll

   198 @released

   199 @see CFbsBitmap::BeginDataAccess()

   200 @see CFbsBitmap::EndDataAccess()

   201 */

   202 EXPORT_C TUint32* CFbsBitmap::DataAddress() const

   203 	{

   204 	if(!iHandle) return(NULL);

   205 	CBitwiseBitmap* bmp = CleanAddress();

   206 

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

   208 		bmp->iSettings.SetVolatileBitmap();

   209 		

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

   211 		{

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

   213 		TAcceleratedBitmapInfo info;

   214 		const TInt ret = hwb.GetInfo(info);

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

   216 		}

   217 

   218 	if (bmp->iHeap == NULL)

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

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

   221 	}

   222 

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

   224 @return The length in bytes between scanlines in memory. 

   225 @internalAll

   226 @released

   227 */

   228 EXPORT_C TInt CFbsBitmap::DataStride() const

   229 	{

   230 	if (!iHandle)

   231 		{

   232 		return 0;

   233 		}

   234 		

   235 	CBitwiseBitmap* bmp = CleanAddress();

   236 	if (bmp==NULL)

   237 		{

   238 		return 0;

   239 		}

   240 		

   241 	return bmp->DataStride();	

   242 	}

   243 

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

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

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

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

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

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

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

   251 if the requested size is too big. 

   252 @publishedAll

   253 @released

   254 */

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

   256 	{

   257 	return DoCreate(aSizeInPixels,aDispMode,KUidCFbsBitmapCreation);

   258 	}

   259 

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

   261 	{

   262 	if(!iFbs) return(KErrCouldNotConnect);

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

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

   265 	if (aDataSize < 0) return KErrArgument;

   266 	Reset();

   267 	TBmpSpec bmpspec;

   268 	bmpspec.iSizeInPixels=aSizeInPixels;

   269 	bmpspec.iDispMode=aDispMode;

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

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

   272 	TPckgBuf<TBmpSpec> b;

   273 	b=bmpspec;

   274 	TIpcArgs args(&b);

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

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

   277 	iHandle=b().iHandle;

   278 	iServerHandle=b().iServerHandle;

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

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

   281 		{

   282 		iFlags = EIsExtendedBitmap;

   283 		}

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

   285 	if (ret != KErrNone)

   286 		return ret;

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

   288 	}

   289 

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

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

   292 @param aDispMode The bitmap's display mode.

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

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

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

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

   297 for that application's use.

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

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

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

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

   302 if hardware bitmaps are not supported on the device. 

   303 @publishedAll

   304 @released

   305 */

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

   307 	{

   308 	return DoCreate(aSizeInPixels,aDispMode,aCreatorUid);

   309 	}

   310 

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

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

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

   314 @param aSizeInPixels The new size of the bitmap. 

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

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

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

   318 @publishedAll

   319 @released

   320 */

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

   322 	{

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

   324 		return(KErrArgument);

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

   326 		return(KErrTooBig);	

   327 	if(!iHandle) 

   328 		return(KErrGeneral);

   329 	if (iFlags & EIsReadOnlyBitmapMask)

   330 		return(KErrAccessDenied);	

   331 	TPckgBuf<TBmpHandles> handlebuf;

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

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

   334 	if (err != KErrNone)

   335 		return (err);

   336 	iHandle = handlebuf().iHandle;

   337 	iServerHandle = handlebuf().iServerHandle;

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

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

   340 	}

   341 

   342 /** Gets the display mode of the bitmap.

   343 @return The display mode of the bitmap. 

   344 @publishedAll

   345 @released

   346 */

   347 EXPORT_C TDisplayMode CFbsBitmap::DisplayMode() const

   348 	{

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

   350 	return CleanAddress()->DisplayMode();

   351 	}

   352 

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

   354 @return The display mode used to create the bitmap.

   355 @publishedAll

   356 @released

   357 */

   358 EXPORT_C TDisplayMode CFbsBitmap::InitialDisplayMode() const

   359 	{

   360 	if(iHandle == NULL) 

   361 		{

   362 		return ENone;

   363 		}

   364 	return CleanAddress()->InitialDisplayMode();

   365 	}

   366 

   367 /**

   368 Changes the display mode of the bitmap.

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

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

   371 additional memory is allocated or leaving methods called.

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

   373 but there may be some loss of quality.

   374 @publishedAll

   375 @released

   376 @param aDisplayMode The requested display mode.

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

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

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

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

   381 @see CFbsBitmap::InitialDisplayMode()

   382 */

   383 EXPORT_C TInt CFbsBitmap::SetDisplayMode(TDisplayMode aDisplayMode)

   384 	{

   385 	if(!iHandle) 

   386 		{

   387 		return KErrGeneral;

   388 		}	

   389 	TUint32* data;

   390 	CBitwiseBitmap* bmp = BeginDataAccessAndGetCleanAddress(data);

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

   392 	EndDataAccess(EFalse);

   393 	return err;

   394 	}

   395 

   396 /** Duplicates a bitmap.

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

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

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

   400 to it.

   401 @param aHandle The handle to an existing bitmap.

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

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

   404 with the specified handle number.

   405 @publishedAll

   406 @released

   407 @see CFbsBitmap::Handle()

   408 */

   409 EXPORT_C TInt CFbsBitmap::Duplicate(TInt aBitmapHandle)

   410 		{

   411 	if(!iFbs) 

   412 		{

   413 		return(KErrCouldNotConnect);

   414 		}

   415 	if(!aBitmapHandle) 

   416 		{

   417 		return(KErrUnknown);

   418 		}

   419 	Reset();

   420 	TBool isinrom=EFalse;

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

   422 	if(ret!=KErrNone) 

   423 		{

   424 		return(KErrUnknown);

   425 		}

   426 	if(isinrom)

   427 		{

   428 		if (((CBitwiseBitmap*)aBitmapHandle)->Uid() != KCBitwiseBitmapUid)

   429 			return(KErrUnknown);

   430 		iAddressPointer = (CBitwiseBitmap*)aBitmapHandle;

   431 		iFlags = EIsRomBitmap;

   432 		iHandle=1;

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

   434 		}

   435 	TPckgBuf<TBmpHandles> b;

   436 	TIpcArgs args(aBitmapHandle,&b);

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

   438 	if(ret!=KErrNone) 

   439 		{

   440 		return(ret);

   441 		}

   442 	iHandle=b().iHandle;

   443 	iServerHandle=b().iServerHandle;

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

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

   446 		{

   447 		iFlags = EIsExtendedBitmap;

   448 		}

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

   450 	if (ret != KErrNone)

   451 		{

   452 		return ret;

   453 		}

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

   455 	}

   456 

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

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

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

   460 @param aId The bitmap identifier.

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

   462 available for sharing between font and bitmap server clients. 

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

   464 codes. 

   465 @publishedAll

   466 @released

   467 */	

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

   469 	{

   470 	return Load(aFileName,aId,aShareIfLoaded,0);

   471 	}

   472 

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

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

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

   476 @param aId The bitmap identifier.

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

   478 available for sharing between FBSERV clients.

   479 @param aFileOffset Bitmap file section offset within the file.

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

   481 @publishedAll

   482 @released

   483 */	

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

   485 	{

   486 	if(!iFbs)

   487 		{

   488 		return(KErrCouldNotConnect);

   489 		}

   490 	Reset();

   491 	TUint32* rompointer = NULL;

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

   493 	IsFileInRom(aFileName, rompointer);

   494 	TBool romPointerValid;

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

   496 	if(romPointerValid)

   497 		{

   498 		return err;

   499 		}

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

   501 	TInt match = aFileName.MatchF(KResourcePath);

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

   503 	if (match == 0)

   504 		{

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

   506 		}

   507 	else

   508 		{

   509 		RFile file;

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

   511 		if (err!=KErrNone)

   512 			{

   513 			return err;

   514 			}

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

   516 		file.Close();

   517 		}

   518 	return err;

   519 	}

   520 

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

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

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

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

   525 @param aId The bitmap identifier.

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

   527 made available for sharing between FBSERV clients.

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

   529 codes. 

   530 @publishedAll 

   531 @released

   532 */	

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

   534     {	

   535     return LoadAndCompress(aFileName, aId, aShareIfLoaded, 0);

   536 	}

   537 

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

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

   540 bitmap is loaded from ROM then compression is not allowed.

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

   542 @param aId The bitmap identifier.

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

   544 available for sharing between FBSERV clients.

   545 @param aFileOffset Bitmap file section offset within the file.

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

   547 codes. 

   548 @publishedAll 

   549 @released

   550 */	

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

   552     {	

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

   554 	if (err == KErrNone)

   555 		{

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

   557 		}

   558 	return err;

   559 	}

   560 

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

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

   563 @param aFilename The name of the file. 

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

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

   566 @publishedAll 

   567 @released

   568 */

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

   570 	{

   571 	if (!iHandle)

   572 		{

   573 		return(KErrGeneral);

   574 		}

   575 	RFile file;

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

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

   578 	TRAP(ret,DoSaveL(file));

   579 	file.Close();

   580 	return(ret);

   581 	}

   582 

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

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

   585 @param aFile The opened file handle

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

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

   588 @publishedAll 

   589 @released

   590 */

   591 EXPORT_C TInt CFbsBitmap::Save(RFile& aFile)

   592 	{

   593 	if (!iHandle)

   594 		{

   595 		return KErrGeneral;

   596 		}

   597 	TRAPD(ret,DoSaveL(aFile));

   598 	return ret;

   599 	}

   600 

   601 void CFbsBitmap::DoSaveL(RFile& aFile)

   602 	{

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

   604 	TUidType uidtype(KDirectFileStoreLayoutUid,KMultiBitmapFileImageUid);

   605 	filestore->SetTypeL(uidtype);

   606 	RStoreWriteStream bmpstream;

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

   608 	ExternalizeL(bmpstream);

   609 	bmpstream.CommitL();

   610 	CleanupStack::PopAndDestroy(); // bitmap stream

   611 	RStoreWriteStream rootstream;

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

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

   614 	rootstream<<bmpstreamid; // stream id of bitmap

   615 	rootstream.CommitL();

   616 	CleanupStack::PopAndDestroy(); // root stream

   617 	filestore->SetRootL(rootstreamid);

   618 	filestore->CommitL();

   619 	CleanupStack::PopAndDestroy(); // file store

   620 	}

   621 

   622 /** Constructs a multi-bitmap file.

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

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

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

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

   627 @publishedAll

   628 @released

   629 */	

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

   631 	{

   632 	CFbsBitmap* bitmap = new(ELeave) CFbsBitmap;

   633 	CleanupStack::PushL(bitmap);

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

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

   636 	CleanupStack::PopAndDestroy(2,bitmap);	

   637 	}

   638 

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

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

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

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

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

   644 @publishedAll

   645 @released

   646 */	

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

   648 	{

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

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

   651 	CleanupStack::PopAndDestroy(filestore);	

   652 	}

   653 

   654 /**

   655 @internalComponent

   656 */

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

   658 	{

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

   660 	TInt count=0;

   661 	for(;count<aNumSources;count++)

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

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

   664 	CleanupArrayDeletePushL(ids);

   665 	TInt nPushed=1;

   666 	if (!aBitmap)

   667 		{

   668 		aBitmap=new(ELeave) CFbsBitmap;

   669 		CleanupStack::PushL(aBitmap);

   670 		++nPushed;

   671 		}

   672 	TUidType uidtype(KDirectFileStoreLayoutUid,KMultiBitmapFileImageUid);

   673 	aFileStore->SetTypeL(uidtype);

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

   675 		{

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

   677 		RStoreWriteStream bmpstream;

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

   679 		aBitmap->ExternalizeL(bmpstream);

   680 		bmpstream.Close();

   681 		CleanupStack::Pop(); // bitmap stream

   682 		}

   683 	RStoreWriteStream rootstream;

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

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

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

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

   688 	rootstream.Close();

   689 	CleanupStack::Pop(); // root stream

   690 	aFileStore->SetRootL(rootstreamid);

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

   692 	}

   693 

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

   695 specified point.

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

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

   698 @param aPoint The start pixel. 

   699 @param aLength The number of pixels to get. 

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

   701 @publishedAll

   702 @released

   703 */

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

   705 	{

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

   707 	}

   708 

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

   710 point and using the specified dither offset.

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

   712 @param aPixel The start pixel. 

   713 @param aLength The number of pixels to get. 

   714 @param aDitherOffset The dither offset of the bitmap. 

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

   716 @publishedAll 

   717 @released

   718 */

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

   720 	{

   721 	if(!iHandle) return;

   722 	TUint32* data;

   723 	CBitwiseBitmap* bmp = BeginDataAccessAndGetCleanAddress(data);

   724 	CFbsRasterizer* rasterizer = NULL;

   725 	if ((iFlags & EIsExtendedBitmap) && iFbs)

   726 		{

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

   728 		if (rasterizer)

   729 			{

   730 			CFbsRasterizer::TBitmapDesc desc;

   731 			desc.iSizeInPixels = bmp->SizeInPixels();

   732 			desc.iDispMode = bmp->DisplayMode();

   733 			desc.iDataType = bmp->iUid;

   734 			desc.iData = data;

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

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

   737 			}

   738 		}

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

   740 	if (rasterizer)

   741 		{

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

   743 		}

   744 	EndDataAccess(ETrue);

   745 	}

   746 

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

   748 scanline contained in the buffer.

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

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

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

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

   753 @publishedAll 

   754 @released

   755 */

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

   757 	{

   758 	if (!iHandle)

   759 		return;	

   760 	if (iFlags & EIsReadOnlyBitmapMask)

   761 		{

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

   763 		return;

   764 		}

   765 	TUint32* data;

   766 	CBitwiseBitmap* bmp = BeginDataAccessAndGetCleanAddress(data);

   767 	if (bmp->IsCompressed())

   768 		{

   769 		EndDataAccess(ETrue);

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

   771 		return;

   772 		}

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

   774 	TInt bytewidth = bmp->iByteWidth;

   775 	TInt bytelen=aBuf.Length();

   776 	if(bytelen<bytewidth) bytewidth=bytelen;

   777 	TInt wordlen=bytewidth>>2;

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

   779 	TUint32* ptrlim=ptr+wordlen;

   780 	while(ptr<ptrlim)

   781 		*data++=*ptr++;

   782 	TInt limit=wordlen<<2;

   783 	if(limit<bytewidth)

   784 		{

   785 		TUint8* byteptr=(TUint8*)ptrlim;

   786 		TUint8* databyte=(TUint8*)data;

   787 		while(limit<bytewidth)

   788 			{

   789 			*databyte++=*byteptr++;

   790 			limit++;

   791 			}

   792 		}

   793 	EndDataAccess(EFalse);

   794 	}

   795 

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

   797 Note: The method only works for uncompressed bitmaps.

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

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

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

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

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

   803 @publishedAll 

   804 @released

   805 */

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

   807 	{

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

   809 	}

   810 

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

   812 and using the specified dither offset.

   813 Note: The method only works for uncompressed bitmaps.

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

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

   816 @param aDitherOffset The dither offset of the bitmap. 

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

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

   819 @publishedAll 

   820 @released

   821 */

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

   823 	{

   824 	if(!iHandle) return;

   825 	TUint32* data;

   826 	CBitwiseBitmap* bmp = BeginDataAccessAndGetCleanAddress(data);

   827 	CFbsRasterizer* rasterizer = NULL;

   828 	if ((iFlags & EIsExtendedBitmap) && iFbs)

   829 		{

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

   831 		if (rasterizer)

   832 			{

   833 			CFbsRasterizer::TBitmapDesc desc;

   834 			desc.iSizeInPixels = bmp->SizeInPixels();

   835 			desc.iDispMode = bmp->DisplayMode();

   836 			desc.iDataType = bmp->iUid;

   837 			desc.iData = data;

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

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

   840 			}

   841 		}

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

   843 	if (rasterizer)

   844 		{

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

   846 		}

   847 	EndDataAccess(ETrue);

   848 	}

   849 

   850 /** Gets the handle number of the bitmap.

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

   852 @return The handle number of the bitmap. 

   853 @publishedAll 

   854 @released

   855 @see CFbsBitmap::Duplicate()

   856 */

   857 EXPORT_C TInt CFbsBitmap::Handle() const

   858 	{

   859 	if(!iHandle) 

   860 		return(0);

   861 	if (iFlags & EIsRomBitmap)

   862 		return TInt(iAddressPointer);

   863 	else

   864 		return(iServerHandle);

   865 	}

   866 

   867 /** Creates a bitmap header.

   868 This is used when streaming bitmaps to stores.

   869 @return The bitmap header for the bitmap. 

   870 @publishedAll 

   871 @released

   872 */

   873 EXPORT_C SEpocBitmapHeader CFbsBitmap::Header() const

   874 	{

   875 	if (iHandle)

   876 		return CleanAddress()->iHeader;

   877 	SEpocBitmapHeader header;

   878 	return(header);

   879 	}

   880 

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

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

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

   884 @publishedAll 

   885 @released

   886 */

   887 EXPORT_C TInt CFbsBitmap::HorizontalPixelsToTwips(TInt aPixels) const

   888 	{

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

   890 	return CleanAddress()->HorizontalPixelsToTwips(aPixels);

   891 	}

   892 

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

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

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

   896 @publishedAll 

   897 @released

   898 */

   899 EXPORT_C TInt CFbsBitmap::HorizontalTwipsToPixels(TInt aTwips) const

   900 	{

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

   902 	return CleanAddress()->HorizontalTwipsToPixels(aTwips);

   903 	}

   904 

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

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

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

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

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

   910 @publishedAll 

   911 @released

   912 */

   913 EXPORT_C void CFbsBitmap::GetPixel(TRgb& aColor,const TPoint& aPoint) const

   914 	{

   915 	if(!iHandle) 

   916 		{

   917 		return;

   918 		}	

   919 	

   920 	TUint32* data;

   921 	CBitwiseBitmap* bmp = BeginDataAccessAndGetCleanAddress(data);

   922 	CFbsRasterizer* rasterizer = NULL;

   923 	if ((iFlags & EIsExtendedBitmap) && iFbs)

   924 		{

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

   926 		if (rasterizer)

   927 			{

   928 			CFbsRasterizer::TBitmapDesc desc;

   929 			desc.iSizeInPixels = bmp->SizeInPixels();

   930 			desc.iDispMode = bmp->DisplayMode();

   931 			desc.iDataType = bmp->iUid;

   932 			desc.iData = data;

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

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

   935 			}

   936 		}

   937 	bmp->GetPixel(aColor, aPoint, data, rasterizer);

   938 	if (rasterizer)

   939 		{

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

   941 		}

   942 	EndDataAccess(ETrue);

   943 	}

   944 

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

   946 @return The size of the bitmap, in pixels. 

   947 @publishedAll 

   948 @released

   949 */

   950 EXPORT_C TSize CFbsBitmap::SizeInPixels() const

   951 	{

   952     TSize zero;

   953 	if(!iHandle) return(zero);

   954 	return CleanAddress()->SizeInPixels();

   955 	}

   956 

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

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

   959 device map.

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

   961 conversion. 

   962 @publishedAll 

   963 @released

   964 */

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

   966 	{

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

   968 		return;

   969 	TSize size=SizeInPixels();

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

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

   972 	iFbs->SetCallBackPtr(&iServerHandle);

   973 	iFbs->CallBack();

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

   975 	Address()->iHeader.iSizeInTwips=size;

   976 	}

   977 

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

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

   980 @publishedAll 

   981 @released

   982 */

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

   984 	{

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

   986 		return;

   987 	iFbs->SetCallBackPtr(&iServerHandle);

   988 	iFbs->CallBack();

   989 	CleanAddress()->iHeader.iSizeInTwips = aSizeInTwips;

   990 	}

   991 

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

   993 @param aStream The write stream. 

   994 @publishedAll 

   995 @released

   996 */

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

   998 	{

   999 	if (!iHandle)

  1000 		User::Leave(KErrGeneral);

  1001 	BeginDataAccess();

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

  1003 	EndDataAccess(ETrue);

  1004 	}

  1005 

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

  1007 rectangular area. Not supported for extended bitmaps.

  1008 @param aStream The write stream

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

  1010 that is externalized will be of this size. 

  1011 @publishedAll 

  1012 @released

  1013 */

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

  1015 	{

  1016 	if (!iHandle)

  1017 		User::Leave(KErrGeneral);

  1018 	BeginDataAccess();

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

  1020 	EndDataAccess(ETrue);

  1021 	}

  1022 

  1023 /** Internalises a CFbsBitmap from a stream.

  1024 @param aStream The read stream.

  1025 @publishedAll 

  1026 @released

  1027 */

  1028 EXPORT_C void CFbsBitmap::InternalizeL(RReadStream& aStream)

  1029 	{

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

  1031 	Reset();

  1032 	SEpocBitmapHeader header;

  1033 	CBitwiseBitmap::InternalizeHeaderL(aStream,header);

  1034 

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

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

  1037 

  1038 	TUint32* data;

  1039 	CBitwiseBitmap* bmp=BeginDataAccessAndGetCleanAddress(data);

  1040 	bmp->iHeader=header;

  1041 	TInt bytesize = header.iBitmapSize - header.iStructSize;

  1042 	if (bytesize > 0)

  1043 		{

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

  1045 		EndDataAccess(EFalse);

  1046 		}

  1047 	else

  1048 		{

  1049 		EndDataAccess(ETrue);

  1050 		}

  1051 	}

  1052 

  1053 EXPORT_C TInt CFbsBitmap::Compress()

  1054  	{

  1055 	return Compress(ERLECompression);

  1056 	}

  1057 

  1058 /** Compresses bitmap in RAM.

  1059 @param aScheme specifies preferred compression type ERLECompression or EPaletteCompression

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

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

  1062 @publishedAll 

  1063 @released

  1064 */

  1065 EXPORT_C TInt CFbsBitmap::Compress(TBitmapfileCompressionScheme aScheme)

  1066 	{

  1067  	if (!iHandle)

  1068  		return KErrGeneral;

  1069  	if (iFlags & EIsReadOnlyBitmapMask)

  1070  		return KErrAccessDenied; 	

  1071 	TPckgBuf<TBmpHandles> handlebuf;

  1072 	TIpcArgs args(iHandle, aScheme, &handlebuf);

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

  1074 	if (err != KErrNone)

  1075 		return err;

  1076 	iHandle = handlebuf().iHandle;

  1077 	iServerHandle = handlebuf().iServerHandle;

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

  1079 	return KErrNone;

  1080 	}

  1081 

  1082 /** Submits the bitmap for asynchronous background compression.

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

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

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

  1086 @publishedAll 

  1087 @released

  1088 */

  1089 EXPORT_C void CFbsBitmap::CompressInBackground(TRequestStatus& aRequestStatus)

  1090 	{

  1091 	CompressInBackground(aRequestStatus, ERLECompression);

  1092 	}

  1093 

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

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

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

  1097 @publishedAll 

  1098 @released

  1099 */

  1100 EXPORT_C TInt CFbsBitmap::CompressInBackground()

  1101 	{

  1102 	return CompressInBackground(ERLECompression);

  1103 	}

  1104 	

  1105 /** Submits the bitmap for asynchronous background compression.

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

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

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

  1109 @param aScheme Specifies preferred compression type: ERLECompression or EPaletteCompression

  1110 @publishedAll 

  1111 @released

  1112 */

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

  1114 	{

  1115 	TRequestStatus* reqStat = &aRequestStatus;

  1116 	aRequestStatus = KRequestPending;

  1117 	if (!iHandle)

  1118 		User::RequestComplete(reqStat, KErrGeneral);

  1119 	else if (iFlags & EIsReadOnlyBitmapMask)

  1120 		User::RequestComplete(reqStat, KErrAccessDenied);	

  1121 	else

  1122 		{

  1123 		TIpcArgs args(iHandle, aScheme, ETrue);

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

  1125 		}

  1126 	}

  1127 

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

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

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

  1131 @publishedAll 

  1132 @released

  1133 */

  1134 EXPORT_C TInt CFbsBitmap::CompressInBackground(TBitmapfileCompressionScheme aScheme)