// 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 <fntstore.h>
#include <bitmap.h>
#include <openfont.h>
#include <graphics/fbsoogmmessage.h>
#include "FbsMessage.H"
#include "SERVER.H"
#include "BackGroundCompression.h"
#include <shapeinfo.h>
#include <graphics/shaperparams.h>
#include "glyphatlas.h"
#include "OstTraceDefinitions.h"
#include "fbstrace.h"
#ifdef OST_TRACE_COMPILER_IN_USE
#include "FBSCLITraces.h"
#endif
/**
Bitwise mask that sets the MSB to indicate to a font rasterizer
that a code is a glyphcode and not a character code
*/
const TUint32 KTreatAsGlyphCodeFlag = 1UL << 31;
/** Helper function for converting a pointer to an offset from the passed
heap base. Use OffsetToPointer() to convert the returned offset back to a
useable pointer.
@param aAny A pointer to be converted to an offset.
@param aHeapBase The heap base of the current process.
@return An offset representing the passed pointer that can be converted
back to a pointer using the function OffsetToPointer().
@see OffsetToPointer()
*/
LOCAL_C TInt PointerToOffset(const TAny* aAny, TInt aHeapBase)
{
TInt offset = 0;
if (aAny && aHeapBase)
{
offset = reinterpret_cast<TInt>(aAny) - aHeapBase;
}
return offset;
}
/** Helper function for converting an offset (that was calculated using
PointerToOffset()) back to a pointer relative to the passed heap base.
@param aOffset The offset to be converted to a pointer.
@param aHeapBase The heap base of the current process.
@return A pointer relative to the passed heap base.
@see PointerToOffset()
*/
LOCAL_C TAny* OffsetToPointer(TInt aOffset, TInt aHeapBase)
{
if (aOffset && aHeapBase)
{
return reinterpret_cast<TAny*>(aOffset + aHeapBase);
}
return NULL;
}
CFbClient::CFbClient(RHeap* aHeap):
CSession2(),
iHeap(aHeap)
#ifdef _DEBUG
,iOwnHeapFailNumber(-1),
iSharedHeapFailNumber(-1)
#endif
{
}
CFbClient* CFbClient::NewL(RHeap* aHeap)
{
CFbClient* self = new (ELeave) CFbClient(aHeap);
CleanupStack::PushL(self);
self->ConstructL();
CleanupStack::Pop(); // self;
return self;
}
/**
Two-phase constructor.
@leave KErrNoMemory if TOpenFontGlyphData construction failed.
*/
void CFbClient::ConstructL()
{
iOpenFontGlyphData = TOpenFontGlyphData::New(iHeap, 4 * 1024);
if (!iOpenFontGlyphData)
{
User::Leave(KErrNoMemory);
}
}
CFbClient::~CFbClient()
{
/*
Don't call any CFontStore functions if CFbClient::NewL has left, or if FBSERV has already deleted the
font store, which happens in test programs like TFBS when FBSERV is closed before the client(s).
*/
CFontStore* font_store = NULL;
CFbTop* fbTop = TopLevelStore();
if (fbTop)
{
font_store = fbTop->FontStore();
}
if (font_store)
{
font_store->DeleteSessionCache(iSessionHandle);
font_store->CleanupCacheOnFbsSessionTermination(iSessionHandle);
// If the font store doesn't exist, neither will the shared heap owned by FBSERV.
iHeap->Free(iOpenFontGlyphData);
}
// delete fonts held by the client
delete iIx;
// delete font files held by the client
if (iFontFileIndex)
{
TInt count = iFontFileIndex->Count();
for (TInt index = 0;index < count; index++)
{
if (font_store)
{
font_store->RemoveFile(iFontFileIndex->At(0).iUid);
}
iFontFileIndex->Delete(0);
}
delete iFontFileIndex;
}
// Close the buffer used to hold the text that needs shaping.
iTextToShape.Close();
for (TInt i = iGlyphImagesInTransit.Count() - 1; i >= 0; --i)
{
iGlyphImagesInTransit[i].Close();
}
iGlyphImagesInTransit.Close();
}
void CFbClient::Init(TUint aConnectionHandle)
{
iConnectionHandle=aConnectionHandle;
}
void CFbClient::CreateL()
{
iIx=CObjectIx::NewL();
iFontFileIndex=new(ELeave) CArrayFixFlat<TFontFileIndex>(1);
}
CFontBitmapServer* CFbClient::FontBitmapServer()
{
return((CFontBitmapServer*)Server());
}
CFbTop* CFbClient::TopLevelStore()
{
CFontBitmapServer* server = FontBitmapServer();
if (server)
{
return server->TopLevelStore();
}
else
{
return NULL;
}
}
void CFbClient::CopyFontInfo(CFontObject* aFontObjPtr,TInt aHandle,TFontInfo& aFontInfo)
{
CBitmapFont* font=aFontObjPtr->iAddressPointer;
aFontInfo.iHandle = aHandle;
aFontInfo.iServerHandle=(TInt)aFontObjPtr;
aFontInfo.iAddressOffset=TInt(font)-TopLevelStore()->HeapBase();
}
void CFbClient::ServiceL(const RMessage2& aMessage)
{
#ifdef _DEBUG
TBool resetOwnHeap=EFalse;
TBool resetSharedHeap=EFalse;
//the memory tests have been mostly written to have start and end memory
//function calls (or macros) at the start of this function call (ServiceL)
//and the matching call (or macro) is at the end of this function.
if (iOwnHeapFailNumber!=-1)
{
//if this not -1 then know to set the heap to fail on
//the given number of allocations
resetOwnHeap=ETrue;
__UHEAP_SETFAIL(RHeap::EDeterministic,iOwnHeapFailNumber);
}
if (iSharedHeapFailNumber!=-1)
{
resetSharedHeap=ETrue;
__RHEAP_SETFAIL (iHeap, RHeap::EDeterministic,iSharedHeapFailNumber);
}
if (iOwnHeapCheck)
{
__UHEAP_MARK;
}
if (iHeapCheck)
{
__RHEAP_MARK(iHeap);
}
#endif
//Call close on RSgImage handles being used to share glyph data with clients.
//The glyph images are held open to prevent the GlyphAtlas from closing them
//before a client can use them.
for (TInt i = iGlyphImagesInTransit.Count() - 1; i >= 0; --i)
{
iGlyphImagesInTransit[i].Close();
iGlyphImagesInTransit.Remove(i);
}
switch(aMessage.Function())
{
// client messages
case EFbsMessInit:
Init(FontBitmapServer()->Init());
iSessionHandle = (TInt)this;
aMessage.Complete(iSessionHandle);
#ifdef _DEBUG
iRet=KErrNone;
#endif
break;
case EFbsMessClose:
{
TInt localhandle=aMessage.Int0();
if(!iIx->At(localhandle))
{
aMessage.Panic(KFBSERVPanicCategory,KErrNotFound);
break;
}
iIx->Remove(localhandle);
iResourceCount--;
aMessage.Complete(KErrNone);
FBS_OST(OstTraceExt3( GRAPHICS_RESOURCE_MANAGEMENT_SEMANTICS, CFBCLIENT_SERVICEL_INFO, "# Server resource destroyed; iSSH=0x%08x; rc=%d; iH=0x%08x;", iSessionHandle, iResourceCount, localhandle);)
#ifdef _DEBUG
iRet=KErrNone;
#endif
break;
}
case EFbsMessResourceCount:
aMessage.Complete(iResourceCount);
#ifdef _DEBUG
iRet=iResourceCount;
#endif
break;
// server messages
case EFbsMessShutdown:
case EFbsMessNumTypefaces:
case EFbsMessTypefaceSupport:
case EFbsMessFontHeightInTwips:
case EFbsMessFontHeightInPixels:
case EFbsMessSetPixelHeight:
case EFbsMessDefaultAllocFail:
case EFbsMessDefaultMark:
case EFbsMessDefaultMarkEnd:
case EFbsMessUserAllocFail:
case EFbsMessUserMark:
case EFbsMessUserMarkEnd:
case EFbsMessHeapCheck:
case EFbsMessSetDefaultGlyphBitmapType:
case EFbsMessGetDefaultGlyphBitmapType:
case EFbsMessFontNameAlias:
case EFbsMessGetHeapSizes:
case EFbsMessDefaultLanguageForMetrics:
case EFbsCompress:
case EFbsMessFetchLinkedTypeface:
case EFbsMessRegisterLinkedTypeface:
case EFbsMessUpdateLinkedTypeface:
#ifdef _DEBUG
FontBitmapServer()->ProcMessage(aMessage,iSessionHandle,iRet);
#else
FontBitmapServer()->ProcMessage(aMessage,iSessionHandle);
#endif
break;
// font messages
case EFbsMessFontDuplicate:
case EFbsMessGetNearestFontToDesignHeightInTwips:
case EFbsMessGetNearestFontToDesignHeightInPixels:
case EFbsMessGetNearestFontToMaxHeightInTwips:
case EFbsMessGetNearestFontToMaxHeightInPixels:
case EFbsMessGetFontById:
case EFbsMessInstallFontStoreFile:
case EFbsMessAddFontStoreFile:
case EFbsMessRemoveFontStoreFile:
case EFbsMessRasterize:
case EFbsMessFaceAttrib:
case EFbsMessHasCharacter:
case EFbsMessShapeText:
case EFbsMessShapeDelete:
case EFbsMessSetTwipsHeight:
case EFbsMessGetTwipsHeight:
case EFbsSetSystemDefaultTypefaceName:
case EFbsMessGetFontTable:
case EFbsMessReleaseFontTable:
case EFbsMessGetGlyphOutline:
case EFbsMessReleaseGlyphOutline:
#if (_DEBUG)
case EFbsMessSetDuplicateFail:
#endif
case EFbsMessGetGlyphs:
case EFbsMessGetGlyphMetrics:
ProcFontMessage(aMessage);
break;
// bitmap messages
case EFbsMessBitmapCreate:
case EFbsMessBitmapResize:
case EFbsMessBitmapDuplicate:
case EFbsMessBitmapLoad:
case EFbsMessBitmapCompress:
case EFbsMessBitmapBgCompress:
case EFbsMessBitmapClean:
case EFbsGetAllBitmapHandles:
case EFbsMessBitmapLoadFast:
case EFbsMessBitmapNotifyDirty:
case EFbsMessBitmapCancelNotifyDirty:
ProcBitmapMessage(aMessage);
break;
//Memory messages
case EFbsMessSetHeapFail:
case EFbsMessHeapCount:
case EFbsMessSetHeapReset:
case EFbsMessSetHeapCheck:
case EFbsMessHeap:
#ifdef _DEBUG
ProcMemMessage(aMessage);
#else
aMessage.Complete(KErrNone);
#endif
break;
// Glyph Atlas messages (debug-only)
case EFbsMessAtlasFontCount:
case EFbsMessAtlasGlyphCount:
#ifdef _DEBUG
ProcAtlasMessage(aMessage);
#else
aMessage.Complete(KErrNotSupported);
#endif
break;
case EFbsMessOogmNotification:
aMessage.Complete( HandleMesgOogmStatus( aMessage ) );
break;
case EFbsMessGetGlyphCacheMetrics:
HandleMesgGlyphCacheMetrics( aMessage );
break;
//No-op message
case EFbsMessNoOp:
#ifdef _DEBUG
iRet = KErrNone;
#endif
aMessage.Complete(KErrNone);
break;
default:
aMessage.Panic(KFBSERVPanicCategory,KErrArgument);
break;
}
#ifdef _DEBUG
//do not want a memory panic if the return code is OK
//__UHEAP_MARKEND does this
if (iOwnHeapCheck)
{
TUint32 badCell=User::Heap().__DbgMarkEnd(0);
if (iRet<0)
{
//if the function call was a success, there may have been valid memory allocations,
//so only panic if the call failed, and the memory is not the same before and after the
//function call
__ASSERT_DEBUG (badCell==NULL,User::Panic(KFBSERVPanicCategory, KErrGeneral));
}
}
if (iHeapCheck)
{
TUint32 badCell2=0;
badCell2= __RHEAP_MARKEND(iHeap);
//the above function call does not panic if there is a failure, this is
//only for the user heap
if (iRet<0)
{
__ASSERT_DEBUG (badCell2==NULL,User::Panic(KFBSERVPanicCategory, KErrGeneral));
}
}
//change the state of the memory check?
if (iOwnHeapCheckFlip)
{
//change the state of the memory testing
//if the mark was set still need to have a mark end
iOwnHeapCheckFlip=EFalse;
iOwnHeapCheck=!iOwnHeapCheck;
}
if (iHeapCheckFlip)
{
iHeapCheckFlip=EFalse;
iHeapCheck=!iHeapCheck;
}
if (resetOwnHeap)
{
//previously set failures, reset
__UHEAP_RESET;
}
if (resetSharedHeap)
{
__RHEAP_RESET (iHeap);
}
#endif
}
/** Handler for EFbsMessFontDuplicate message
@param aMessage input parameters
@param aPanicRequired flag that is set if a client panic is required
@return KErrNone if successful, otherwise a system wide error code
*/
TInt CFbClient::HandleMesgFontDuplicate(const RMessage2& aMessage, TBool& aPanicRequired)
{
#if _DEBUG
if (iFontDuplicateToFail)
{
return KErrNoMemory; //return with this error since this error is possible
}
#endif
CFontObject* fontptr = (CFontObject*) aMessage.Int0();
if(!TopLevelStore()->ValidFontHandle((TInt)fontptr))
{
return KErrUnknown;
}
TPckgBuf<TFontInfo> fontinfo;
TInt localhandle = 0;
TInt ret = fontptr->Open();
if (ret != KErrNone)
{
return ret;
}
TRAP(ret, localhandle=iIx->AddL(fontptr));
if (ret != KErrNone)
{
fontptr->Close();
return ret;
}
CopyFontInfo(fontptr,localhandle,fontinfo());
fontptr->iHeightInTwips = ((fontptr->iAddressPointer->HeightInPixels() * fontptr->iFontStore->iKPixelHeightInTwips) + 667) / 1000;
ret = aMessage.Write(1, fontinfo);
if(ret != KErrNone)
{
iIx->Remove(localhandle);
aPanicRequired = ETrue;
return ret;
}
// success
iResourceCount++;
FBS_OST(OstTraceExt3( GRAPHICS_RESOURCE_MANAGEMENT_SEMANTICS, CFBCLIENT_HANDLEMESGFONTDUPLICATE_INFO, "# Server font duplicated; iSSH=0x%08x; rc=%d; iH=0x%08x;", iSessionHandle, iResourceCount, localhandle);)
return KErrNone;
}
/** Handler for EFbsMessGetNearestFontToDesignHeightInTwips, EFbsMessGetNearestFontToDesignHeightInPixels,
EFbsMessGetNearestFontToMaxHeightInTwips or EFbsMessGetNearestFontToMaxHeightInPixels messages
@param aMessage input and output parameters
@param aPanicRequired flag that is set if a client panic is required
@return KErrNone if successful, otherwise a system wide error code
*/
TInt CFbClient::HandleMesgGetNearestFont(const RMessage2& aMessage, TBool& aPanicRequired)
{
CFontObject* fontptr = NULL;
TPckgBuf<TFontSpec> pckgFontSpec;
TInt pckgMaxHeight;
TPckgBuf<TSizeInfo> info;
const TFbsMessage fbsMessage = static_cast<TFbsMessage>(aMessage.Function());
TInt ret = aMessage.Read(0, pckgFontSpec);
TFontSpec& fontSpec = pckgFontSpec();
if (ret == KErrNone )
{
TInt length = fontSpec.iTypeface.iName.Length();
if((length < 0) || (length > TOpenFontFaceAttribBase::ENameLength))
{
aPanicRequired = ETrue;
return KErrArgument;
}
ret = aMessage.Read(2, info);
if (ret == KErrNone)
{
pckgMaxHeight = info().iMaxHeight;
TopLevelStore()->FontStore()->iKPixelHeightInTwips=info().iDevSize.iHeight;
TopLevelStore()->FontStore()->iKPixelWidthInTwips=info().iDevSize.iWidth;
}
}
if (KErrNone != ret)
{
aPanicRequired = ETrue;
return ret;
}
if ( (EFbsMessGetNearestFontToMaxHeightInTwips == fbsMessage) || (EFbsMessGetNearestFontToMaxHeightInPixels == fbsMessage) )
{
ret = TopLevelStore()->GetNearestFont(fontptr, fbsMessage, fontSpec, pckgMaxHeight);
}
else
{
ret = TopLevelStore()->GetNearestFont(fontptr, fbsMessage, fontSpec);
}
if (ret == KErrNone)
{ // package up the result
ret = CopyFontInfoIntoReturnMessage(aMessage, aPanicRequired, fontptr, 1);
}
return ret;
}
/** package up the font that was found - includes cleanup handling in case of error
@param aMessage input and output parameters
@param aPanicRequired flag that is set if a client panic is required
@param aFontObj the object that is to be returned
@param aWritePosition the slot position in the message pointing to the receiving object
@return KErrNone if successful, otherwise a system wide error code
*/
TInt CFbClient::CopyFontInfoIntoReturnMessage(const RMessage2& aMessage, TBool& aPanicRequired, CFontObject* aFontObj, TInt aWritePosition)
{
TInt localhandle = 0;
TRAPD(ret, localhandle = iIx->AddL(aFontObj));
if (KErrNone != ret)
{
aFontObj->Close();
return ret;
}
TPckgBuf<TFontInfo> pckgFontInfo;
CopyFontInfo(aFontObj, localhandle, pckgFontInfo());
ret = aMessage.Write(aWritePosition, pckgFontInfo);
if (KErrNone != ret)
{
iIx->Remove(localhandle);
aPanicRequired = ETrue;
return ret;
}
// success
iResourceCount++;
FBS_OST(OstTraceExt3( GRAPHICS_RESOURCE_MANAGEMENT_SEMANTICS, CFBCLIENT_COPYFONTINFOINTORETURNMESSAGE_INFO, "# Server font duplicated; iSSH=0x%08x; rc=%d; iH=0x%08x;", iSessionHandle, iResourceCount, localhandle);)
return KErrNone;
}
/** Handler for EFbsMessGetFontById message
Works for Bitmap fonts only, see implementation in CFbTop::GetFontById() & CFontStore::GetFontById().
@param aMessage input and output parameters
@param aPanicRequired flag that is set if a client panic is required
@return KErrNone if successful, otherwise a system wide error code
*/
TInt CFbClient::HandleMesgGetFontById(const RMessage2& aMessage, TBool& aPanicRequired)
{
CFontObject* fontptr = NULL;
TPckgBuf<TAlgStyle> algstyle;
TPckgBuf<TSize> size;
TInt ret = aMessage.Read(1, algstyle);
if (ret == KErrNone)
{ // get font size
ret = aMessage.Read(3, size);
if (ret == KErrNone)
{
TopLevelStore()->FontStore()->iKPixelHeightInTwips = size().iHeight;
TopLevelStore()->FontStore()->iKPixelWidthInTwips = size().iWidth;
}
}
if (ret != KErrNone)
{
aPanicRequired = ETrue;
return ret;
}
TUid fileid;
fileid.iUid = aMessage.Int2();
ret = TopLevelStore()->GetFontById(fontptr,fileid,algstyle());
if (ret == KErrNone)
{ // package up the result
ret = CopyFontInfoIntoReturnMessage(aMessage, aPanicRequired, fontptr, 0);
}
return ret;
}
/** Handler for EFbsMessInstallFontStoreFile or EFbsMessAddFontStoreFile messages
@param aMessage input and output parameters
@param aPanicRequired flag that is set if a client panic is required
@return KErrNone if successful, otherwise a system wide error code
*/
TInt CFbClient::HandleMesgAddOrInstallFontFile(const RMessage2& aMessage, TBool& aPanicRequired)
{
TPckgBuf<TIntParcel> id;
TInt length=aMessage.Int1();
if(length < 0 || length * sizeof(TText) >= KMaxTInt/2)
{
aPanicRequired = ETrue;
return KErrArgument;
}
TText* buffer=(TText*)User::Alloc(length*sizeof(TText));
if(buffer==NULL)
{
return KErrNoMemory;
}
TPtr filename(buffer,length,length);
TInt ret = aMessage.Read(0,filename);
if(ret!=KErrNone)
{
User::Free(buffer);
aPanicRequired = ETrue;
return ret;
}
TRAP(ret, id().iInt = TopLevelStore()->FontStore()->AddFileL(filename).iUid);
User::Free(buffer);
if (ret != KErrNone)
{
return ret;
}
TUid uid;
uid.iUid=id().iInt;
if (aMessage.Function() == EFbsMessAddFontStoreFile)
{
TRAP(ret, AddFontFileIndexL(uid));
if (ret!=KErrNone)
{
TopLevelStore()->FontStore()->RemoveFile(uid);
return ret;
}
}
ret = aMessage.Write(2,id);
if (ret!=KErrNone)
{
RemoveFontFileIndex(uid);
aPanicRequired = ETrue;
}
return ret;
}
/** Handler for EFbsMessRemoveFontStoreFile message
@param aMessage input parameters
@return KErrNone if successful
*/
TInt CFbClient::HandleMesgRemoveFontFile(const RMessage2& aMessage)
{
TUid uid;
uid.iUid=aMessage.Int0();
RemoveFontFileIndex(uid);
return KErrNone;
}
/** Handler for EFbsMessRasterize message
@param aMessage input parameters
@param aPanicRequired flag that is set if a client panic is required
@return ETrue if successful, EFalse or any system-wide error code if not successful.
*/
TInt CFbClient::HandleMesgRasterize(const RMessage2& aMessage, TBool& aPanicRequired)
{
CFbTop* fbtop = TopLevelStore();
CFontObject* fontptr = static_cast<CFontObject*>(iIx->At(aMessage.Int0(), fbtop->FontConUniqueID()));
if(!fontptr)
{
aPanicRequired = ETrue;
return KErrArgument;
}
CBitmapFont* bitmapFont = fontptr->iAddressPointer;
const TUint charCode = aMessage.Int1();
if ( (bitmapFont != NULL) && (bitmapFont->Rasterize(iSessionHandle, charCode, iOpenFontGlyphData)) )
{
// Convert all pointers to be passed back to the client to offsets from
// the heap base so that they can be recreated client side relative to the
// client's heap base
TInt heapbase = fbtop->HeapBase();
TPckgBuf<TRasterizeParams> params;
params().iMetricsOffset = PointerToOffset(iOpenFontGlyphData->Metrics(), heapbase);
params().iBitmapPointerOffset = PointerToOffset(iOpenFontGlyphData->BitmapPointer(), heapbase);;
TInt err = aMessage.Write(2, params);
if (KErrNone != err)
{
aPanicRequired = ETrue;
return err;
}
return ETrue;
}
return EFalse;
}
/** Handler for EFbsMessGetGlyphs message.
Reads a batch of up to KMaxGlyphBatchSize glyph codes, and on success returns
the corresponding TGlyphImageInfo objects.
@param aMessage input parameters
@param aPanicRequired flag that is set if a client panic is required
@return KErrNone if successful, otherwise any system-wide error code.
*/
TInt CFbClient::HandleMesgGetGlyphs(const RMessage2& aMessage, TBool& aPanicRequired)
{
CFbTop* fbtop = TopLevelStore();
// Previously requested glyphs were closed in ServiceL()
CGlyphAtlas* glyphAtlas = fbtop->GlyphAtlas();
if (!glyphAtlas)
{
return KErrNotSupported;
}
CFontObject* fontptr = static_cast<CFontObject*>(iIx->At(aMessage.Int0(), fbtop->FontConUniqueID()));
if(!fontptr)
{
aPanicRequired = ETrue;
return KErrBadHandle;
}
TUint glyphCodes[KMaxGlyphBatchSize];
TGlyphImageInfo glyphImageInfo[KMaxGlyphBatchSize];
TPckg<TUint[KMaxGlyphBatchSize]> glyphBatchPckg(glyphCodes);
TInt err = aMessage.Read(1, glyphBatchPckg);
if (err != KErrNone)
{
aPanicRequired = ETrue;
return err;
}
TInt glyphCodesCount = glyphBatchPckg.Length() / sizeof(TUint);
if (glyphCodesCount > KMaxGlyphBatchSize)
{
aPanicRequired = ETrue;
return KErrOverflow;
}
TInt glyphsProcessed = 0;
CBitmapFont* font = fontptr->iAddressPointer;
for (; (glyphsProcessed < glyphCodesCount); ++glyphsProcessed)
{
TUint32 glyphCode = glyphCodes[glyphsProcessed];
err = glyphAtlas->GetGlyph(*font, glyphCode, glyphImageInfo[glyphsProcessed]);
// Search for glyph in glyph atlas
if (KErrNone != err)
{
const TUint8* bitmapData = NULL;
TOpenFontCharMetrics metrics;
// search for glyph in font glyph cache and session cache.
if (!font->GetCharacterData(iSessionHandle, glyphCode | KTreatAsGlyphCodeFlag, metrics, bitmapData))
{
// Rasterize the glyph
if(!font->Rasterize(iSessionHandle, glyphCode | KTreatAsGlyphCodeFlag, iOpenFontGlyphData))
{
err = KErrNoMemory;
break;
}
metrics = *(iOpenFontGlyphData->Metrics());
bitmapData = iOpenFontGlyphData->BitmapPointer();
}
CGlyphAtlas::TAddGlyphArgs args(bitmapData, glyphCode, metrics);
err = glyphAtlas->AddGlyph(*font, args, glyphImageInfo[glyphsProcessed]);
}
if ((err == KErrNone) && (glyphImageInfo[glyphsProcessed].iImageId != KSgNullDrawableId))
{
// To prevent other threads closing the glyph image in the glyph atlas
// before client has had chance to open the drawable id, open a local
// handle to the glyph image for the session, which will be closed either
// next time a request is made or when EFbsMessCloseGlyphs is handled.
RSgImage glyphImage;
err = glyphImage.Open(glyphImageInfo[glyphsProcessed].iImageId);
if (err == KErrNone)
{
err = iGlyphImagesInTransit.Append(glyphImage);
}
}
// If an error occurred during this iteration, abort now before the glyphsProcessed
// counter is incremented, which would give one too many processed glyphs.
if (KErrNone != err)
{
break;
}
}
// Even if there was an error, if at least one glyph was processed successfully
// send that back to the client, and reset the error code.
if (glyphsProcessed > 0)
{
TPckg<TGlyphImageInfo[KMaxGlyphBatchSize]> glyphImageInfoPckg(glyphImageInfo);
glyphImageInfoPckg.SetLength(glyphsProcessed * sizeof(TGlyphImageInfo));
err = aMessage.Write(2, glyphImageInfoPckg);
if (err != KErrNone)
{
aPanicRequired = ETrue;
return err;
}
}
else
{
// No glyphs being returned, so an error code must be returned.
__ASSERT_DEBUG(err != KErrNone, User::Panic(KFBSERVPanicCategory, err));
}
return err;
}
/**
Handler for EFbsMessGetGlyphMetrics message.
Reads an array of glyph codes, and returns the offset from the heap base for the
corresponding metrics object.
@pre The glyph codes have already been searched client-side in the font glyph
cache and the session cache.
@param aMessage input parameters
@param aPanicRequired flag that is set if a client panic is required
@return KErrNone if successful, otherwise any system-wide error code.
*/
TInt CFbClient::HandleMesgGetGlyphMetrics(const RMessage2& aMessage, TBool& aPanicRequired)
{
CFbTop* fbtop = TopLevelStore();
CFontObject* fontptr = static_cast<CFontObject*>(iIx->At(aMessage.Int0(), fbtop->FontConUniqueID()));
if(!fontptr)
{
aPanicRequired = ETrue;
return KErrBadHandle;
}
TInt err = KErrNone;
TUint glyphCodes[KMaxMetricsBatchSize];
TPckg<TUint[KMaxMetricsBatchSize]> glyphBatchPckg(glyphCodes);
err = aMessage.Read(1, glyphBatchPckg);
if (err != KErrNone)
{
aPanicRequired = ETrue;
return err;
}
TInt numGlyphCodes = glyphBatchPckg.Length() / sizeof(TUint);
if (numGlyphCodes > KMaxMetricsBatchSize)
{
aPanicRequired = ETrue;
return KErrOverflow;
}
CBitmapFont* font = fontptr->iAddressPointer;
const TInt heapbase = fbtop->HeapBase();
TInt glyphProcessed;
TInt glyphMetricsOffsets[KMaxMetricsBatchSize];
for (glyphProcessed = 0; (glyphProcessed < numGlyphCodes) && (err == KErrNone); ++glyphProcessed)
{
if (font->Rasterize(iSessionHandle, glyphCodes[glyphProcessed] | KTreatAsGlyphCodeFlag, iOpenFontGlyphData))
{
// Convert all pointers to be passed back to the client to offsets from
// the heap base so that they can be recreated client side relative to the
// client's heap base
glyphMetricsOffsets[glyphProcessed] = PointerToOffset(iOpenFontGlyphData->Metrics(), heapbase);
}
else
{
err = KErrNoMemory;
}
}
if (err == KErrNone)
{
TPckg<TInt[KMaxMetricsBatchSize]> glyphMetricsOffsetsPckg(glyphMetricsOffsets);
glyphMetricsOffsetsPckg.SetLength(glyphProcessed * sizeof(TInt));
err = aMessage.Write(2, glyphMetricsOffsetsPckg);
if (err != KErrNone)
{
aPanicRequired = ETrue;
}
}
return err;
}
/** Handler for EFbsMessFaceAttrib message
@param aMessage Input and output parameters
@param aPanicRequired Flag that is set to ETrue if a client panic is required
@return ETrue if successful, EFalse or any system-wide error code if not successful.
An error code is only returned if aPanicRequired is set to ETrue.
*/
TInt CFbClient::HandleMesgFaceAttrib(const RMessage2& aMessage, TBool& aPanicRequired)
{
CFontObject* fontptr = static_cast<CFontObject*>(iIx->At(aMessage.Int0(), TopLevelStore()->FontConUniqueID()));
if(!fontptr)
{
aPanicRequired = ETrue;
return KErrArgument;
}
CBitmapFont* bitmapFont = fontptr->iAddressPointer;
TInt ret = EFalse;
TPckgBuf<TOpenFontFaceAttrib> package;
if ( (bitmapFont != NULL) && (bitmapFont->GetFaceAttrib(package())) )
{
ret = aMessage.Write(1,package);
if (ret == KErrNone)
{
ret = ETrue;
}
else
{
aPanicRequired = ETrue;
}
}
return ret;
}
/** Handler for EFbsMessHasCharacter message
@param aMessage Input parameters
@param aPanicRequired Flag that is set to ETrue if a client panic is required
@return ETrue if the font has the character, EFalse if the font does not have
the character, or any system-wide error code if not successful. An error code
is only returned if aPanicRequired is set to ETrue.
*/
TInt CFbClient::HandleMesgHasCharacter(const RMessage2& aMessage, TBool& aPanicRequired)
{
CFontObject* fontptr = static_cast<CFontObject*>(iIx->At(aMessage.Int0(), TopLevelStore()->FontConUniqueID()));
if(!fontptr)
{
aPanicRequired = ETrue;
return KErrArgument;
}
CBitmapFont* bitmapFont = fontptr->iAddressPointer;
TInt ret = 0;
TRAPD(error, ret = bitmapFont->HasCharacterL(aMessage.Int1()));
if (error != KErrNone)
{
return EFalse;
}
return ret;
}
/** Handler for EFbsMessShapeText message
@param aMessage Input and output parameters
@param aPanicRequired Flag that is set to ETrue if a client panic is required
@return An offset from the heap base where the pointer to the shape is located
if successful, otherwise 0 or any system-wide error code. An error code is
only returned if aPanicRequired is set to ETrue.
*/
TInt CFbClient::HandleMesgShapeText(const RMessage2& aMessage, TBool& aPanicRequired)
{
TInt error = KErrNone;
TShapeHeader* shape = 0;
if (aMessage.GetDesLength(2) != sizeof(TShapeMessageParameters))
{
aPanicRequired = ETrue;
return KErrArgument;
}
CFbTop* fbtop = TopLevelStore();
CFontObject* fontptr = static_cast<CFontObject*>(iIx->At(aMessage.Int0(), fbtop->FontConUniqueID()));
if(!fontptr)
{
aPanicRequired = ETrue;
return KErrArgument;
}
TInt inputTextLength = aMessage.GetDesLength(1);
if (inputTextLength < 0)
{
error = inputTextLength;
aPanicRequired = ETrue;
return error;
}
else
{
iTextToShape.Zero();
if (iTextToShape.MaxLength() < inputTextLength)
{
error = iTextToShape.ReAlloc(inputTextLength);
}
}
if (error == KErrNone)
{
error = aMessage.Read(1, iTextToShape);
if (error != KErrNone)
{
aPanicRequired = ETrue;
return error;
}
TPckgBuf<TShapeMessageParameters> sp;
error = aMessage.Read(2, sp);
if (error != KErrNone)
{
aPanicRequired = ETrue;
return error;
}
CBitmapFont* bitmapFont = fontptr->iAddressPointer;
TRAP(error, shape = bitmapFont->ShapeTextL(iTextToShape, iSessionHandle, sp()) );
if (error == KErrNone)
{
// Convert the pointer to be passed back to the client to an offset from
// the heap base so that it can be recreated client side relative to the
// client's heap base
return PointerToOffset(shape, fbtop->HeapBase());
}
}
return 0;
}
/** Handler for EFbsMessShapeDelete message
@param aMessage input and output parameters
@param aPanicRequired flag that is set to ETrue if a client panic is required
@return KErrNone if successful, otherwise a system wide error code
An error code is only returned if aPanicRequired is set to ETrue.
*/
TInt CFbClient::HandleMesgShapeDelete(const RMessage2& aMessage, TBool& aPanicRequired)
{
CFbTop* fbtop = TopLevelStore();
CFontObject* fontptr = static_cast<CFontObject*>(iIx->At(aMessage.Int0(), fbtop->FontConUniqueID()));
if(!fontptr)
{
aPanicRequired = ETrue;
return KErrArgument;
}
CBitmapFont* bitmapFont = fontptr->iAddressPointer;
// Combine the passed shape offset with the current heap base to get
// a valid pointer to a shape header for use in this process
TShapeHeader* shapeheader = reinterpret_cast<TShapeHeader*>(OffsetToPointer(aMessage.Int1(), fbtop->HeapBase()));
bitmapFont->DeleteShape(iSessionHandle,shapeheader);
return KErrNone;
}
TInt CFbClient::HandleMesgReleaseGlyphOutline(const RMessage2& aMessage, TBool& aPanicRequired)
{
TInt ret = KErrNone;
CFbTop* fbtop = TopLevelStore();
TPckgBuf<TFBSGlyphOutlineParam> params;
ret = aMessage.Read(0, params);
if (KErrNone != ret)
{
aPanicRequired = ETrue;
return ret;
}
CFontObject* fontptr = static_cast<CFontObject*>(iIx->At(params().iHandle, fbtop->FontConUniqueID()));
if(!fontptr)
{
aPanicRequired = ETrue;
return KErrArgument;
}
CBitmapFont* bitmapFont = fontptr->iAddressPointer;
TInt count = params().iCount;
TUint *glyphCodes = (TUint *)User::Alloc(count * sizeof(TUint));
if (NULL == glyphCodes)
{
return KErrNoMemory;
}
// copy the glyph codes out of the IPC buffer...
TPtr8 ptr((TUint8 *)glyphCodes, count * sizeof(TUint), count * sizeof(TUint));
ret = aMessage.Read(1, ptr);
if (KErrNone == ret)
{
bitmapFont->ReleaseGlyphOutlines(count, glyphCodes,
params().iHinted, iSessionHandle);
}
else
{
aPanicRequired = ETrue;
}
User::Free(glyphCodes);
return ret;
}
TInt CFbClient::HandleMesgGetGlyphOutline(const RMessage2& aMessage, TBool& aPanicRequired)
{
TInt ret = KErrNone;
CFbTop* fbtop = TopLevelStore();
TPckgBuf<TFBSGlyphOutlineParam> params;
ret = aMessage.Read(0, params);
if (KErrNone != ret)
{
aPanicRequired = ETrue;
return ret;
}
CFontObject* fontptr = static_cast<CFontObject*>(iIx->At(params().iHandle, fbtop->FontConUniqueID()));
if(!fontptr)
{
aPanicRequired = ETrue;
return KErrArgument;
}
CBitmapFont* bitmapFont = fontptr->iAddressPointer;
TInt count = params().iCount;
TUint* glyphCodes = (TUint *)User::Alloc(count * sizeof(TUint));
if (NULL == glyphCodes)
{
return KErrNoMemory;
}
// copy the glyph codes out of the IPC buffer...
TPtr8 ptr((TUint8 *)glyphCodes, count * sizeof(TUint), count * sizeof(TUint));
ret = aMessage.Read(1, ptr);
if (KErrNone != ret)
{
User::Free(glyphCodes);
aPanicRequired = ETrue;
return ret;
}
TOffsetLen* offsetLens =
(TOffsetLen *)User::Alloc(count * sizeof(TOffsetLen));
if (NULL == offsetLens)
{
User::Free(glyphCodes);
return KErrNoMemory;
}
TInt len = 0;
TAny* outline = NULL;
for (TInt i = 0; i < count; ++i)
{
bitmapFont->GetGlyphOutline(glyphCodes[i],
params().iHinted, outline, len, iSessionHandle);
offsetLens[i].iLen = len;
offsetLens[i].iOffset = PointerToOffset((outline), fbtop->HeapBase());
}
TPtr8 pkg2((TUint8 *)offsetLens, count * sizeof(TOffsetLen),
count * sizeof(TOffsetLen));
ret = aMessage.Write(2, pkg2);
if (KErrNone != ret)
{
aPanicRequired = ETrue;
}
User::Free(glyphCodes);
User::Free(offsetLens);
return ret;
}
TInt CFbClient::HandleMesgReleaseFontTable(const RMessage2& aMessage, TBool& aPanicRequired)
{
CFbTop* fbtop = TopLevelStore();
CFontObject* fontptr = static_cast<CFontObject*>(iIx->At(aMessage.Int0(), fbtop->FontConUniqueID()));
if(!fontptr)
{
aPanicRequired = ETrue;
return KErrArgument;
}
CBitmapFont* bitmapFont = fontptr->iAddressPointer;
TUint32 tag = aMessage.Int1();
bitmapFont->ReleaseFontTable(tag, iSessionHandle);
return KErrNone;
}
TInt CFbClient::HandleMesgGetFontTable(const RMessage2& aMessage, TBool& aPanicRequired)
{
TInt ret = KErrNone;
CFbTop* fbtop = TopLevelStore();
CFontObject* fontptr = static_cast<CFontObject*>(iIx->At(aMessage.Int0(), fbtop->FontConUniqueID()));
if(!fontptr)
{
aPanicRequired = ETrue;
return KErrArgument;
}
CBitmapFont* bitmapFont = fontptr->iAddressPointer;
TInt len = 0;
TAny* tablePtr = NULL;
ret = bitmapFont->GetFontTable((TUint32)aMessage.Int1(), tablePtr, len, iSessionHandle);
if (KErrNone == ret)
{
TPckgBuf<TOffsetLen> params;
params().iLen = len;
params().iOffset = PointerToOffset(tablePtr, fbtop->HeapBase());
ret = aMessage.Write(2, params);
aPanicRequired = (KErrNone != ret);
}
return ret;
}
/**
Called in response to the GoomMonitor framework's call into FbsOogmPlugin.
We wish to either free some GPU memory, or reinstate its normal usage.
@param aMessage The IPC message.
@return KErrNone If the value contained in the TFbsOogmMessage enumeration member is meaningful and the glyph atlas is present.
KErrNotSupported if there is no glyph atlas.
KErrUnknown if the value contained in the TFbsOogmMessage enumeration member is not meaningful.
*/
TInt CFbClient::HandleMesgOogmStatus( const RMessage2& aMessage )
{
TInt ret = KErrNone;
CGlyphAtlas* glyphAtlas = TopLevelStore()->GlyphAtlas();
if ( NULL == glyphAtlas )
{
return KErrNotSupported;
}
TPckgBuf<TFbsOogmMessage> oogmMessage;
aMessage.Read( 0, oogmMessage );
switch( oogmMessage().iOogmNotification )
{
case TFbsOogmMessage::EFbsOogmNoAction:
break;
case TFbsOogmMessage::EFbsOogmLowNotification:
{
glyphAtlas->ReleaseGpuMemory( oogmMessage().iBytesToFree, oogmMessage().iFlags );
}
break;
case TFbsOogmMessage::EFbsOogmOkayNotification:
{
glyphAtlas->InstateGpuMemory( oogmMessage().iFlags );
}
break;
default:
ret = KErrUnknown;
break;
}
return ret;
}
void CFbClient::HandleMesgGlyphCacheMetrics( const RMessage2& aMessage )
{
CGlyphAtlas* glyphAtlas = TopLevelStore()->GlyphAtlas();
TPckgBuf<TGlyphCacheMetrics> metrics;
glyphAtlas->GetGlyphCacheMetrics( metrics() );
aMessage.Complete( aMessage.Write(0, metrics) );
}
void CFbClient::ProcFontMessage(const RMessage2& aMessage)
{
TInt ret = KErrNone;
TBool panicRequired = EFalse;
switch(aMessage.Function())
{
case EFbsMessFontDuplicate:
ret = HandleMesgFontDuplicate(aMessage, panicRequired);
break;
case EFbsMessGetNearestFontToDesignHeightInTwips:
case EFbsMessGetNearestFontToDesignHeightInPixels:
case EFbsMessGetNearestFontToMaxHeightInTwips:
case EFbsMessGetNearestFontToMaxHeightInPixels:
ret = HandleMesgGetNearestFont(aMessage, panicRequired);
break;
case EFbsMessGetFontById:
ret = HandleMesgGetFontById(aMessage, panicRequired);
break;
case EFbsMessInstallFontStoreFile:
case EFbsMessAddFontStoreFile:
ret = HandleMesgAddOrInstallFontFile(aMessage, panicRequired);
break;
case EFbsMessRemoveFontStoreFile:
ret = HandleMesgRemoveFontFile(aMessage);
break;
case EFbsMessRasterize:
ret = HandleMesgRasterize(aMessage, panicRequired);
break;
case EFbsMessFaceAttrib:
ret = HandleMesgFaceAttrib(aMessage, panicRequired);
break;
case EFbsMessHasCharacter:
ret = HandleMesgHasCharacter(aMessage, panicRequired);
break;
case EFbsMessShapeText:
ret = HandleMesgShapeText(aMessage, panicRequired);
break;
case EFbsMessShapeDelete:
ret = HandleMesgShapeDelete(aMessage, panicRequired);
break;
case EFbsMessSetTwipsHeight:
{
TInt localhandle=aMessage.Int0();
CFontObject* fontptr = static_cast<CFontObject*>(iIx->At(localhandle, TopLevelStore()->FontConUniqueID()));
if(!fontptr)
{
panicRequired = ETrue;
ret = KErrArgument;
break;
}
fontptr->iHeightInTwips = aMessage.Int1();
ret = KErrNone;
break;
}
case EFbsMessGetTwipsHeight:
{
TInt localhandle=aMessage.Int0();
CFontObject* fontptr = static_cast<CFontObject*>(iIx->At(localhandle, TopLevelStore()->FontConUniqueID()));
if(!fontptr)
{
panicRequired = ETrue;
ret = KErrArgument;
break;
}
TPckgBuf<TInt> height;
height() = fontptr->iHeightInTwips;
ret = aMessage.Write(1,height);
if (KErrNone != ret)
{
panicRequired = ETrue;
}
break;
}
case EFbsSetSystemDefaultTypefaceName:
{
TBuf<KMaxTypefaceNameLength> fontTypefaceName;
ret = aMessage.GetDesLength(0);
if (ret < 0)
{
panicRequired = ETrue;
break;
}
if (ret <= KMaxTypefaceNameLength) // Size in characters i.e. 2 bytes for unicode
{
ret = aMessage.Read(0, fontTypefaceName);
if (ret == KErrNone)
{
TopLevelStore()->SetSystemDefaultTypefaceName(fontTypefaceName);
}
}
else
{
panicRequired = ETrue;
ret = KErrTooBig;
}
break;
}
case EFbsMessGetFontTable:
{
ret = HandleMesgGetFontTable(aMessage, panicRequired);
break;
}
case EFbsMessGetGlyphOutline:
{
ret = HandleMesgGetGlyphOutline(aMessage, panicRequired);
break;
}
case EFbsMessReleaseGlyphOutline:
{
ret = HandleMesgReleaseGlyphOutline(aMessage, panicRequired);
break;
}
case EFbsMessReleaseFontTable:
{
ret = HandleMesgReleaseFontTable(aMessage, panicRequired);
break;
}
case EFbsMessGetGlyphs:
{
ret = HandleMesgGetGlyphs(aMessage, panicRequired);
break;
}
case EFbsMessGetGlyphMetrics:
{
ret = HandleMesgGetGlyphMetrics(aMessage, panicRequired);
break;
}
#ifdef _DEBUG
case EFbsMessSetDuplicateFail:
{
TInt argument =aMessage.Int0();
if (argument)
{
iFontDuplicateToFail = ETrue;
}
else
{
iFontDuplicateToFail = EFalse;
}
ret=KErrNone;
break;
}
#endif
default:
ret = KErrUnknown;
}
// either have a result or an error code to panic the client with
if (panicRequired)
{
aMessage.Panic(KFBSERVPanicCategory, ret);
}
else
{
if(!aMessage.IsNull())
{
aMessage.Complete(ret);
}
}
#ifdef _DEBUG
iRet=ret;
#endif
}
void CFbClient::ProcBitmapMessage(const RMessage2 &aMessage)
{
CBitmapObject* bmpptr=NULL;
TInt localhandle=0;
TInt ret = KErrNone;
switch(aMessage.Function())
{
case EFbsMessBitmapCreate:
{
TPckgBuf<TBmpSpec> bs;
ret = aMessage.Read(0,bs);
if(ret!=KErrNone)
{
aMessage.Panic(KFBSERVPanicCategory,ret);
return;
}
TBmpSpec& bmpSpec = bs();
if(!TDisplayModeUtils::IsDisplayModeValid(bmpSpec.iDispMode))
{
aMessage.Panic(KFBSERVPanicCategory,KErrArgument);
return;
}
// client uses iHandle to pass UID and iServerHandle to pass data size
TRAP(ret, bmpptr = TopLevelStore()->CreateBitmapL(bmpSpec.iSizeInPixels, bmpSpec.iDispMode, TUid::Uid(bmpSpec.iHandle), EFalse, bmpSpec.iServerHandle));
if(ret!=KErrNone)
break;
TRAP(ret,localhandle=iIx->AddL(bmpptr));
if(ret!=KErrNone)
{
bmpptr->Close();
break;
}
bmpSpec.iHandle=localhandle;
bmpSpec.iServerHandle = bmpptr->Handle();
bmpSpec.iAddressOffset=TInt(bmpptr->Address())-TopLevelStore()->HeapBase();
ret = aMessage.Write(0,bs);
if(ret!=KErrNone)
{
iIx->Remove(localhandle);
aMessage.Panic(KFBSERVPanicCategory,ret);
return;
}
iResourceCount++;
FBS_OST(OstTraceExt5( GRAPHICS_RESOURCE_MANAGEMENT_SEMANTICS, CFBCLIENT_PROCBITMAPMESSAGE_INFO, "# Server bitmap created; iSSH=0x%08x; rc=%d; iH=0x%08x; iSH=0x%08x; bytes=%d;", iSessionHandle, iResourceCount, bmpSpec.iHandle, bmpSpec.iServerHandle, bmpptr->Address()->DataStride() * bmpSpec.iSizeInPixels.iHeight);)
break;
}
case EFbsMessBitmapLoad:
case EFbsMessBitmapLoadFast:
{
TPckgBuf<TLoadBitmapArg> loadBitmapArg;
ret = aMessage.Read(1,loadBitmapArg);
if(ret!=KErrNone)
{
aMessage.Panic(KFBSERVPanicCategory,ret);
return;
}
const TInt32 id=loadBitmapArg().iBitmapId;
const TBool shareifloaded=loadBitmapArg().iShareIfLoaded;
const TUint fileOffset = loadBitmapArg().iFileOffset;
if(aMessage.Function() == EFbsMessBitmapLoad)
{
RFile file;
ret=file.AdoptFromClient(aMessage,2,3);
if (ret!=KErrNone)
{
break;
}
TFileName filename;
ret=file.FullName(filename);
if (ret!=KErrNone)
{
break;
}
if(shareifloaded)
{
TRAP(ret, bmpptr=TopLevelStore()->ShareBitmapL(filename, id, fileOffset,&file, iSessionHandle));
}
else
{
TRAP(ret, bmpptr=TopLevelStore()->LoadBitmapL(filename, id, fileOffset, &file, iSessionHandle));
}
file.Close();
}
else
{
TFileName filename;
ret = aMessage.Read(2,filename);
if (ret!=KErrNone)
{
aMessage.Panic(KFBSERVPanicCategory,ret);
return;
}
_LIT(KZDrive, "z:");
if (filename.Left(2).CompareF(KZDrive))
{
// File is not in the Z: drive.
// So open the file and pass the file handle to LoadBitmapL() or ShareBitmapL() and close it afterwards.
// The reason is that the cache cannot be used for files that are writable,
// since they can't be kept open in the cache.
RFile file;
ret = file.Open(TopLevelStore()->FileSession(),filename,EFileShareReadersOnly);
if (ret!=KErrNone)
{
break;
}
if(shareifloaded)
{
TRAP(ret, bmpptr=TopLevelStore()->ShareBitmapL(filename, id, fileOffset,&file, iSessionHandle));
}
else
{
TRAP(ret, bmpptr=TopLevelStore()->LoadBitmapL(filename, id, fileOffset, &file, iSessionHandle));
}
file.Close();
}
else
{
if(shareifloaded)
{
TRAP(ret, bmpptr=TopLevelStore()->ShareBitmapL(filename, id, fileOffset, NULL, iSessionHandle));
}
else
{
TRAP(ret, bmpptr=TopLevelStore()->LoadBitmapL(filename, id, fileOffset, NULL, iSessionHandle));
}
}
}
if(ret!=KErrNone)
{
break;
}
TRAP(ret,localhandle=iIx->AddL(bmpptr));
if(ret!=KErrNone)
{
bmpptr->Close();
break;
}
TPckgBuf<TBmpHandles> handlebuffer;
handlebuffer().iHandle=localhandle;
handlebuffer().iServerHandle = bmpptr->Handle();
handlebuffer().iAddressOffset=TInt(bmpptr->Address())-TopLevelStore()->HeapBase();
ret = aMessage.Write(0,handlebuffer);
if(ret!=KErrNone)
{
iIx->Remove(localhandle);
aMessage.Panic(KFBSERVPanicCategory,ret);
return;
}
iResourceCount++;
FBS_OST(OstTraceExt5( GRAPHICS_RESOURCE_MANAGEMENT_SEMANTICS, CFBCLIENT_PROCBITMAPMESSAGE_INFO2, "# Server bitmap loaded; iSSH=0x%08x; rc=%d; iH=0x%08x; iSH=0x%08x; bytes=%d;", iSessionHandle, iResourceCount, handlebuffer().iHandle, handlebuffer().iServerHandle, bmpptr->Address()->DataStride() * bmpptr->Address()->SizeInPixels().iHeight);)
break;
}
case EFbsMessBitmapResize:
{
localhandle=aMessage.Int0();
CFbTop* fbtop = TopLevelStore();
bmpptr = static_cast<CBitmapObject*>(iIx->At(localhandle, fbtop->BitmapConUniqueID()));
if(!bmpptr)
{
ret=KErrUnknown;
break;
}
ret = fbtop->GetCleanBitmap(bmpptr);
if (ret != KErrNone)
{
break;
}
TSize newsize(aMessage.Int1(),aMessage.Int2());
const TBool compressedInRam = bmpptr->Address()->IsCompressedInRAM(); //It must be set before the resizing is done.
const TDisplayMode dispMode = bmpptr->Address()->DisplayMode();
CBitmapObject* newbmpptr = NULL;
TRAP(ret, newbmpptr = fbtop->CreateBitmapL(newsize, dispMode, KUidCFbsBitmapCreation, ETrue));
if (ret != KErrNone)
{
break;
}
ret = newbmpptr->Address()->CopyData(*bmpptr->Address());
if (ret != KErrNone)
{
newbmpptr->Close();
break;
}
if (compressedInRam)
{
// if the header says PaletteCompression specify.
TBitmapfileCompressionScheme scheme = ERLECompression;
if (bmpptr->Address()->iHeader.iCompression == EGenericPaletteCompression)
scheme = EPaletteCompression;
ret = newbmpptr->Address()->CompressData(scheme); // re-compress
if (ret != KErrNone)
{
newbmpptr->Close();
break;
}
}
TInt newlocalhandle = 0;
TRAP(ret, newlocalhandle = iIx->AddL(newbmpptr));
if (ret != KErrNone)
{
newbmpptr->Close();
break;
}
ret = newbmpptr->Open();
if (ret != KErrNone)
{
iIx->Remove(newlocalhandle);
break;
}
bmpptr->SetCleanBitmap(newbmpptr);
if (bmpptr->AccessCount() >= 2)
{
fbtop->NotifyDirtyBitmap(*bmpptr, this);
}
iIx->Remove(localhandle);
TPckgBuf<TBmpHandles> handlebuffer;
handlebuffer().iHandle = newlocalhandle;
handlebuffer().iServerHandle = newbmpptr->Handle();
handlebuffer().iAddressOffset = TInt(newbmpptr->Address()) - fbtop->HeapBase();
ret = aMessage.Write(3, handlebuffer);
if (ret != KErrNone)
{
iIx->Remove(newlocalhandle);
aMessage.Panic(KFBSERVPanicCategory, ret);
return;
}
FBS_OST(OstTraceExt5( GRAPHICS_RESOURCE_MANAGEMENT_SEMANTICS, CFBCLIENT_PROCBITMAPMESSAGE_INFO4, "# Server bitmap resized; iSSH=0x%08x; iOldH=0x%08x; iNewH=0x%08x; iNewSH=0x%08x; newbytes=%d;", iSessionHandle, localhandle, newlocalhandle, newbmpptr->Handle(), newbmpptr->Address()->DataStride() * newsize.iHeight);)
break;
}
case EFbsMessBitmapDuplicate:
{
bmpptr = TopLevelStore()->FindBitmap(aMessage.Int0());
if (bmpptr == NULL)
{
ret=KErrUnknown;
break;
}
//coverity [check_return]
//coverity [unchecked_value]
TopLevelStore()->GetCleanBitmap(bmpptr);
ret = bmpptr->Open();
if (ret != KErrNone)
{
break;
}
TPckgBuf<TBmpHandles> handlebuffer;
TRAP(ret,localhandle=iIx->AddL(bmpptr));
if(ret!=KErrNone)
{
bmpptr->Close();
break;
}
handlebuffer().iHandle = localhandle;
handlebuffer().iServerHandle = bmpptr->Handle();
handlebuffer().iAddressOffset = TInt(bmpptr->Address()) - TopLevelStore()->HeapBase();
ret = aMessage.Write(1, handlebuffer);
if(ret!=KErrNone)
{
iIx->Remove(localhandle);
aMessage.Panic(KFBSERVPanicCategory,ret);
return;
}
iResourceCount++;
FBS_OST(OstTraceExt5( GRAPHICS_RESOURCE_MANAGEMENT_SEMANTICS, CFBCLIENT_PROCBITMAPMESSAGE_INFO3, "# Server bitmap duplicated; iSSH=0x%08x; rc=%d; iH=0x%08x; iSH=0x%08x; bytes=%d;", iSessionHandle, iResourceCount, handlebuffer().iHandle, handlebuffer().iServerHandle, bmpptr->Address()->DataStride() * bmpptr->Address()->SizeInPixels().iHeight);)
break;
}
case EFbsMessBitmapCompress:
{
localhandle = aMessage.Int0();
CFbTop* fbtop = TopLevelStore();
bmpptr = static_cast<CBitmapObject*>(iIx->At(localhandle, fbtop->BitmapConUniqueID()));
if(!bmpptr)
{
ret = KErrUnknown;
break;
}
ret = fbtop->GetCleanBitmap(bmpptr);
if (ret != KErrNone)
{
break;
}
const TSize size = bmpptr->Address()->SizeInPixels();
const TDisplayMode dispMode = bmpptr->Address()->DisplayMode();
CBitmapObject* newbmpptr = NULL;
TRAP(ret, newbmpptr = fbtop->CreateBitmapL(size, dispMode, KUidCFbsBitmapCreation, ETrue));
if (ret != KErrNone)
{
break;
}
ret = newbmpptr->Address()->CopyData(*bmpptr->Address());
if (ret != KErrNone)
{
newbmpptr->Close();
break;
}
ret = newbmpptr->Address()->CompressData((TBitmapfileCompressionScheme)aMessage.Int1());
if (ret != KErrNone)
{
newbmpptr->Close();
break;
}
TInt newlocalhandle = 0;
TRAP(ret, newlocalhandle = iIx->AddL(newbmpptr));
if (ret != KErrNone)
{
newbmpptr->Close();
break;
}
ret = newbmpptr->Open();
if (ret != KErrNone)
{
iIx->Remove(newlocalhandle);
break;
}
bmpptr->SetCleanBitmap(newbmpptr);
if (bmpptr->AccessCount() >= 2)
{
fbtop->NotifyDirtyBitmap(*bmpptr, this);
}
iIx->Remove(localhandle);
TPckgBuf<TBmpHandles> handlebuffer;
handlebuffer().iHandle = newlocalhandle;
handlebuffer().iServerHandle = newbmpptr->Handle();
handlebuffer().iAddressOffset = TInt(newbmpptr->Address()) - fbtop->HeapBase();
ret = aMessage.Write(2, handlebuffer);
if (ret != KErrNone)
{
iIx->Remove(newlocalhandle);
aMessage.Panic(KFBSERVPanicCategory, ret);
return;
}
FBS_OST(OstTraceExt4( GRAPHICS_RESOURCE_MANAGEMENT_SEMANTICS, CFBCLIENT_PROCBITMAPMESSAGE_INFO5, "# Server bitmap compressed; iSSH=0x%08x; iOldH=0x%08x; iNewH=0x%08x; iNewSH=0x%08x;", (TUint)iSessionHandle, localhandle, newlocalhandle, handlebuffer().iServerHandle);)
break;
}
case EFbsMessBitmapBgCompress:
{
localhandle = aMessage.Int0();
TBitmapfileCompressionScheme scheme = (TBitmapfileCompressionScheme)aMessage.Int1();
TBool async = aMessage.Int2();
CFbTop* fbtop = TopLevelStore();
bmpptr = static_cast<CBitmapObject*>(iIx->At(localhandle, fbtop->BitmapConUniqueID()));
if(!bmpptr)
{
ret = KErrUnknown;
break;
}
ret = fbtop->GetCleanBitmap(bmpptr);
if (ret != KErrNone)
{
if (!async)
{
ret = KErrNone;
}
break;
}
ret = bmpptr->Address()->CheckBackgroundCompressData();
if (KErrNone == ret)
{
ret = fbtop->BackgroundCompression()->AddToCompressionQueue(bmpptr, scheme, async ? &aMessage : NULL);
if (ret == KErrNone && async)
{
return; // do not complete the client's request - that will be done by the background compression thread
}
}
if (KErrAlreadyExists == ret)
{
ret = KErrNone;
}
break;
}
case EFbsMessBitmapClean:
{
TInt localhandle = aMessage.Int0();
CFbTop* fbtop = TopLevelStore();
bmpptr = static_cast<CBitmapObject*>(iIx->At(localhandle, fbtop->BitmapConUniqueID()));
if(!bmpptr)
{
ret = KErrUnknown;
break;
}
ret = fbtop->GetCleanBitmap(bmpptr);
if (ret != KErrNone)
{
break;
}
ret = bmpptr->Open();
if (ret != KErrNone)
{
break;
}
TInt cleanlocalhandle = 0;
TRAP(ret, cleanlocalhandle = iIx->AddL(bmpptr));
if (ret != KErrNone)
{
bmpptr->Close();
break;
}
iIx->Remove(localhandle);
TPckgBuf<TBmpHandles> handlebuffer;
handlebuffer().iHandle = cleanlocalhandle;
handlebuffer().iServerHandle = bmpptr->Handle();
handlebuffer().iAddressOffset = TInt(bmpptr->Address()) - fbtop->HeapBase();
ret = aMessage.Write(1, handlebuffer);
if (ret != KErrNone)
{
iIx->Remove(cleanlocalhandle);
aMessage.Panic(KFBSERVPanicCategory, ret);
return;
}
FBS_OST(OstTraceExt3( GRAPHICS_RESOURCE_MANAGEMENT_SEMANTICS, CFBCLIENT_PROCBITMAPMESSAGE_INFO6, "# Server bitmap cleaned; iSSH=0x%08x; iOldH=0x%08x; iNewH=0x%08x;", iSessionHandle, localhandle, cleanlocalhandle);)
break;
}
case EFbsGetAllBitmapHandles:
{
ret = TopLevelStore()->GetAllBitmapHandles(aMessage);
break;
}
case EFbsMessBitmapNotifyDirty:
{
if (iHelper == NULL)
{
iHelper = new TFbClientHelper(*this);
if (iHelper == NULL)
{
ret = KErrNoMemory;
break;
}
TopLevelStore()->AddClientHelper(*iHelper);
}
if (!iHelper->iMessage.IsNull())
{
aMessage.Panic(KFBSERVPanicCategory, KErrAlreadyExists);
return;
}
if (!iHelper->iDirty)
{
iHelper->iMessage = aMessage;
return; // do not complete the client's request yet - that will be done when a bitmap becomes dirty
}
iHelper->iDirty = EFalse;
}
break;
case EFbsMessBitmapCancelNotifyDirty:
{
if (iHelper != NULL && !iHelper->iMessage.IsNull())
{
iHelper->iMessage.Complete(KErrCancel);
}
}
break;
default:
ret = KErrUnknown;
}
if(!aMessage.IsNull())
{
aMessage.Complete(ret);
}
#ifdef _DEBUG
iRet=ret;
#endif
}
void CFbClient::NotifyDirtyBitmap(CBitmapObject& aBmpObj)
{
if (iHelper != NULL && iIx->At(&aBmpObj) != KErrNotFound)
{
iHelper->iDirty = ETrue;
if (!iHelper->iMessage.IsNull())
{
iHelper->iMessage.Complete(KErrNone);
iHelper->iDirty = EFalse;
}
}
}
void CFbClient::AddFontFileIndexL(TUid aId)
{
TInt count=iFontFileIndex->Count();
for (TInt index=0;index<count;index++)
{
if (iFontFileIndex->At(index).iUid==aId)
{
iFontFileIndex->At(index).iAccessCount++;
TopLevelStore()->FontStore()->RemoveFile(aId);
return;
}
}
TFontFileIndex fontFileIndex;
fontFileIndex.iUid=aId;
fontFileIndex.iAccessCount=1;
iFontFileIndex->AppendL(fontFileIndex);
}
void CFbClient::RemoveFontFileIndex(TUid aId)
{
TInt count=iFontFileIndex->Count();
for (TInt index=0;index<count;index++)
{
TFontFileIndex* fontFileIndex=&iFontFileIndex->At(index);
if (fontFileIndex->iUid==aId)
{
fontFileIndex->iAccessCount--;
if (fontFileIndex->iAccessCount<1)
{
TopLevelStore()->FontStore()->RemoveFile(fontFileIndex->iUid);
iFontFileIndex->Delete(index);
}
return;
}
}
// not found - must be an installed file or rubbish, so try anyway
TopLevelStore()->FontStore()->RemoveFile(aId);
}
void CFbClient::Disconnect(const RMessage2 &aMessage)
{
// if any bitmaps are in the background compression queue with a to-be-completed RMessage2 from this session,
// the RMessage2 must be completed now as it is only possible to complete messages on existing sessions
TopLevelStore()->BackgroundCompression()->CompleteOutstandingRequests(this);
// if there is a to-be-completed request for dirty bitmap notification complete it now
if (iHelper)
{
if (!iHelper->iMessage.IsNull())
{
iHelper->iMessage.Complete(KErrDisconnected);
}
iHelper->Deque();
delete iHelper;
iHelper = NULL;
}
// Clear the mbm file store cache resources that corresponds to this session
TopLevelStore()->CloseFileStores(iSessionHandle);
CSession2::Disconnect(aMessage);
}
#ifdef _DEBUG
void CFbClient::ProcMemMessage(const RMessage2 &aMessage)
{
TInt ret=KErrNone;
TInt parameterForFunctionCall;
TInt cells = User::Heap().Available(parameterForFunctionCall);
switch(aMessage.Function())
{
case EFbsMessSetHeapFail:
if (aMessage.Int0()==RFbsSession::EHeapFailTypeServerMemory)
{
iOwnHeapFailNumber=aMessage.Int1();
}
else
{
iSharedHeapFailNumber=aMessage.Int1();
}
break;
case EFbsMessHeapCount:
if (aMessage.Int0()==RFbsSession::EHeapFailTypeServerMemory)
{
ret=User::CountAllocCells();
}
else
{
ret=iHeap->Count();
}
break;
case EFbsMessSetHeapReset:
if (aMessage.Int0()==RFbsSession::EHeapFailTypeServerMemory)
{
iOwnHeapFailNumber=-1;
}
else
{
iSharedHeapFailNumber=-1;
}
break;
case EFbsMessSetHeapCheck:
if (aMessage.Int0()==RFbsSession::EHeapFailTypeServerMemory)
{
iOwnHeapCheckFlip=ETrue;
}
else
{
iHeapCheckFlip=ETrue;
}
break;
case EFbsMessHeap:
ret=(TInt)iHeap;
break;
default:
ret = KErrUnknown;
}
aMessage.Complete(ret);
iRet=ret;
}
/**
Processes messages associated with the Glyph Atlas.
@param aMessage The message used to perform IPC to the client.
*/
void CFbClient::ProcAtlasMessage(const RMessage2 &aMessage)
{
TInt ret = KErrNone;
CFbTop* fbtop = TopLevelStore();
CGlyphAtlas* glyphAtlas = fbtop->GlyphAtlas();
if (!glyphAtlas)
{
ret = KErrNotSupported;
}
else
{
switch(aMessage.Function())
{
case EFbsMessAtlasFontCount:
ret = glyphAtlas->FontCount();
break;
case EFbsMessAtlasGlyphCount:
{
TInt fontHandle = aMessage.Int0();
if (fontHandle != 0)
{
if (fbtop->ValidFontHandle(fontHandle))
{
CFontObject* fontptr = reinterpret_cast<CFontObject*>(fontHandle);
ret = glyphAtlas->GlyphCount(static_cast<CBitmapFont&>(*(fontptr->iAddressPointer)));
}
else
{
ret = KErrNotFound;
}
}
else
{
ret = glyphAtlas->GlyphCount();
}
}
break;
default:
ret = KErrUnknown;
}
}
aMessage.Complete(ret);
iRet=ret;
}
#endif