diff -r e8c1ea2c6496 -r 8758140453c0 graphics/fbserv/src/T_DataFbsSession.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graphics/fbserv/src/T_DataFbsSession.cpp Thu Jan 21 12:53:44 2010 +0000 @@ -0,0 +1,749 @@ +/* +* Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Symbian Foundation License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +/** +@test +@internalComponent + +This contains CT_DataFbsSession +*/ + +#include "T_DataFbsSession.h" +#include "T_GraphicsUtil.h" + + +/*@{*/ +/// Parameters +_LIT(KSession, "session"); +_LIT(KInvalidSession, "invalid_session"); +_LIT(KNullSession, "null_session"); +_LIT(KExpectedCallBack, "expected"); +_LIT(KExpectedDiff, "expected_diff"); +_LIT(KFbsMessage, "fbs_message"); +_LIT(KBitmap, "bitmap"); +_LIT(KFbsParameter0, "parameter0"); +_LIT(KFbsParameter1, "parameter1"); +_LIT(KFbsParameter2, "parameter2"); +_LIT(KFbsParameter3, "parameter3"); +_LIT(KVersionName, "name"); +_LIT(KVersionBuild, "build"); +_LIT(KVersionMajor, "major"); +_LIT(KVersionMinor, "minor"); + +/// Commands +_LIT(KCmdConstructor, "Constructor"); +_LIT(KCmdConnect, "Connect"); +_LIT(KCmdDisconnect, "Disconnect"); +_LIT(KCmdGetSession, "GetSession"); +_LIT(KCmdCallBack, "CallBack"); +_LIT(KCmdSetCallBack, "SetCallBack"); +_LIT(KCmdResetCallBack, "ResetCallBack"); +_LIT(KCmdResourceCount, "ResourceCount"); +_LIT(KCmdSendCommand, "SendCommand"); +_LIT(KCmdVersion, "Version"); +_LIT(KCmdHeapBase, "HeapBase"); +_LIT(KCmdSessionHandle, "SessionHandle"); + +_LIT(KFbsMessInit, "EFbsMessInit"); +_LIT(KFbsMessShutdown, "EFbsMessShutdown"); +_LIT(KFbsMessClose, "EFbsMessClose"); +_LIT(KFbsMessResourceCount, "EFbsMessResourceCount"); +_LIT(KFbsMessNumTypefaces, "EFbsMessNumTypefaces"); +_LIT(KFbsMessTypefaceSupport, "EFbsMessTypefaceSupport"); +_LIT(KFbsMessFontHeightInTwips, "EFbsMessFontHeightInTwips"); +_LIT(KFbsMessFontHeightInPixels, "EFbsMessFontHeightInPixels"); +_LIT(KFbsMessAddFontStoreFile, "EFbsMessAddFontStoreFile"); +_LIT(KFbsMessInstallFontStoreFile, "EFbsMessInstallFontStoreFile"); +_LIT(KFbsMessRemoveFontStoreFile, "EFbsMessRemoveFontStoreFile"); +_LIT(KFbsMessSetPixelHeight, "EFbsMessSetPixelHeight"); +_LIT(KFbsMessGetFontById, "EFbsMessGetFontById"); +_LIT(KFbsMessFontDuplicate, "EFbsMessFontDuplicate"); +_LIT(KFbsMessBitmapCreate, "EFbsMessBitmapCreate"); +_LIT(KFbsMessBitmapResize, "EFbsMessBitmapResize"); +_LIT(KFbsMessBitmapDuplicate, "EFbsMessBitmapDuplicate"); +_LIT(KFbsMessBitmapLoad, "EFbsMessBitmapLoad"); +_LIT(KFbsMessDefaultAllocFail, "EFbsMessDefaultAllocFail"); +_LIT(KFbsMessDefaultMark, "EFbsMessDefaultMark"); +_LIT(KFbsMessDefaultMarkEnd, "EFbsMessDefaultMarkEnd"); +_LIT(KFbsMessUserAllocFail, "EFbsMessUserAllocFail"); +_LIT(KFbsMessUserMark, "EFbsMessUserMark"); +_LIT(KFbsMessUserMarkEnd, "EFbsMessUserMarkEnd"); +_LIT(KFbsMessHeapCheck, "EFbsMessHeapCheck"); +_LIT(KFbsMessRasterize, "EFbsMessRasterize"); +_LIT(KFbsMessFaceAttrib, "EFbsMessFaceAttrib"); +_LIT(KFbsMessHasCharacter, "EFbsMessHasCharacter"); +_LIT(KFbsMessSetDefaultGlyphBitmapType, "EFbsMessSetDefaultGlyphBitmapType"); +_LIT(KFbsMessGetDefaultGlyphBitmapType, "EFbsMessGetDefaultGlyphBitmapType"); +_LIT(KFbsMessFontNameAlias, "EFbsMessFontNameAlias"); +_LIT(KFbsMessBitmapCompress, "EFbsMessBitmapCompress"); +_LIT(KFbsMessGetHeapSizes, "EFbsMessGetHeapSizes"); +_LIT(KFbsMessGetNearestFontToDesignHeightInTwips, "EFbsMessGetNearestFontToDesignHeightInTwips"); +_LIT(KFbsMessGetNearestFontToMaxHeightInTwips, "EFbsMessGetNearestFontToMaxHeightInTwips"); +_LIT(KFbsMessGetNearestFontToDesignHeightInPixels, "EFbsMessGetNearestFontToDesignHeightInPixels"); +_LIT(KFbsMessGetNearestFontToMaxHeightInPixels, "EFbsMessGetNearestFontToMaxHeightInPixels"); +_LIT(KFbsMessShapeText, "EFbsMessShapeText"); +_LIT(KFbsMessShapeDelete, "EFbsMessShapeDelete"); +_LIT(KFbsMessDefaultLanguageForMetrics, "EFbsMessDefaultLanguageForMetrics"); +_LIT(KFbsMessSetTwipsHeight, "EFbsMessSetTwipsHeight"); +_LIT(KFbsMessGetTwipsHeight, "EFbsMessGetTwipsHeight"); +_LIT(KFbsCompress, "EFbsCompress"); +_LIT(KFbsMessBitmapBgCompress, "EFbsMessBitmapBgCompress"); +_LIT(KFbsSetSystemDefaultTypefaceName, "EFbsSetSystemDefaultTypefaceName"); +_LIT(KFbsGetAllBitmapHandles, "EFbsGetAllBitmapHandles"); +_LIT(KFbsMessCreateLinkedTypeface, "EFbsMessCreateLinkedTypeface"); +_LIT(KFbsMessSetHeapFail, "EFbsMessSetHeapFail"); +_LIT(KFbsMessHeapCount, "EFbsMessHeapCount"); +_LIT(KFbsMessSetHeapReset, "EFbsMessSetHeapReset"); +_LIT(KFbsMessSetHeapCheck, "EFbsMessSetHeapCheck"); +_LIT(KFbsMessHeap, "EFbsMessHeap"); +_LIT(KFbsMessLinkedCache, "EFbsMessLinkedCache"); +_LIT(KFbsMessBitmapClean, "EFbsMessBitmapClean"); +/*@}*/ + +/** +* Two phase constructor +*/ +CT_DataFbsSession* CT_DataFbsSession::NewL() + { + CT_DataFbsSession* ret = new (ELeave) CT_DataFbsSession(); + CleanupStack::PushL(ret); + ret->ConstructL(); + CleanupStack::Pop(ret); + return ret; + } + +/** +* Protected constructor. First phase construction +*/ +CT_DataFbsSession::CT_DataFbsSession() +: CDataWrapperBase() +, iSession(NULL) +, iResourceCount(-1) +, iCallBackCalled(EFalse) + { + } + +/** +* Second phase construction +*/ +void CT_DataFbsSession::ConstructL() + { + } + +/** +* Protected destructor. +*/ +CT_DataFbsSession::~CT_DataFbsSession() + { + } + +/** +* Process a command read from the ini file +* +* @param aDataWrapper test step requiring command to be processed +* @param aCommand the command to process +* @param aSection the entry in the ini file requiring the command to be processed +* +* @return ETrue if the command is processed +*/ +TBool CT_DataFbsSession::DoCommandL(const TTEFFunction& aCommand, const TTEFSectionName& aSection, const TInt /*aAsyncErrorIndex*/) + { + TBool ret=ETrue; + + if (aCommand == KCmdConstructor) + { + DoCmdConstructor(); + } + else if (aCommand == KCmdConnect) + { + DoCmdConnect(aSection); + } + else if (aCommand == KCmdDisconnect) + { + DoCmdDisconnect(); + } + else if (aCommand == KCmdGetSession) + { + DoCmdGetSession(aSection); + } + else if (aCommand == KCmdCallBack) + { + DoCmdCallBack(aSection); + } + else if (aCommand == KCmdResetCallBack) + { + DoCmdResetCallBack(); + } + else if (aCommand == KCmdSetCallBack) + { + DoCmdSetCallBack(); + } + else if (aCommand == KCmdResourceCount) + { + DoCmdResourceCount(aSection); + } + else if (aCommand == KCmdSendCommand) + { + DoCmdSendCommandL(aSection); + } + else if (aCommand == KCmdVersion) + { + DoCmdVersion(aSection); + } + else if (aCommand == KCmdHeapBase) + { + DoCmdHeapBase(); + } + else if (aCommand == KCmdSessionHandle) + { + DoCmdSessionHandle(); + } + else + { + ret=EFalse; + } + + return ret; + } + + +void CT_DataFbsSession::DoCmdConstructor() + { + INFO_PRINTF1(_L("Call RFbsSession's constructor")); + + RFbsSession tempSession; + } + + +/** RFbsSession::Connect() Call */ +void CT_DataFbsSession::DoCmdConnect(const TDesC& aSection) + { + INFO_PRINTF1(_L("RFbsSession::Connect() call")); + + TBool session=EFalse; + GetBoolFromConfig(aSection, KSession(), session); + + TBool invalidSession=EFalse; + GetBoolFromConfig(aSection, KInvalidSession(), invalidSession); + + TInt err=KErrNone; + if ( session ) + { + err=RFbsSession::Connect(FileServer()); + } + else if ( invalidSession ) + { + err=RFbsSession::Connect(iFsUnconnected); + } + else + { + err=RFbsSession::Connect(); + } + + if ( err!=KErrNone ) + { + ERR_PRINTF2(_L("Connect failed with error %d"), err); + SetError(err); + } + } + +/** RFbsSession::Disconnect() call */ +void CT_DataFbsSession::DoCmdDisconnect() + { + INFO_PRINTF1(_L("RFbsSession::Disconnect() call")); + RFbsSession::Disconnect(); + } + +/** RFbsSession::GetSession() check */ +void CT_DataFbsSession::DoCmdGetSession(const TDesC& aSection) + { + INFO_PRINTF1(_L("RFbsSession::GetSession() check")); + + // get not_null_session parameter value + + TBool nullSessionExpected = EFalse; + GetBoolFromConfig(aSection, KNullSession(), nullSessionExpected); + + // check result of GetSession() method + iSession = RFbsSession::GetSession(); + + if ( nullSessionExpected ) + { + if ( iSession != NULL ) + { + // Session is expected to be null but it is not null + ERR_PRINTF1(_L("Session is expected to be null but it is not null!")); + SetBlockResult(EFail); + } + } + else + { + if ( iSession == NULL ) + { + ERR_PRINTF1(_L("Session is expected to be not null but it is null!")); + SetBlockResult(EFail); + } + } + } + + +/** RFbsSession::CallBack() call */ +void CT_DataFbsSession::DoCmdCallBack(const TDesC& aSection) + { + INFO_PRINTF1(_L("RFbsSession::CallBack() call")); + iCallBackCalled=EFalse; + iSession->CallBack(); + + // get expected callback parameter value + TBool expected; + if( GetBoolFromConfig(aSection, KExpectedCallBack(), expected) ) + { + if ( expected != iCallBackCalled ) + { + ERR_PRINTF3(_L("Expected callback %d does not equal actual callback %d"), expected, iCallBackCalled); + SetBlockResult(EFail); + } + } + } + + +/** Set call back function uding RFbsSession::SetCallBack() */ +void CT_DataFbsSession::DoCmdSetCallBack() + { + INFO_PRINTF1(_L("Set call back function uding SetCallBack()")); + TCallBack callBack(CallBackFunction, this); + iCallBackCalled=EFalse; + iSession->SetCallBack(callBack); + } + + +/** RFbsSession::ResetCallBack() call */ +void CT_DataFbsSession::DoCmdResetCallBack() + { + INFO_PRINTF1(_L("RFbsSession::ResetCallBack() call")); + iCallBackCalled=EFalse; + iSession->ResetCallBack(); + } + + +/** RFbsSession::ResourceCount() call, memorize resource count */ +void CT_DataFbsSession::DoCmdResourceCount(const TDesC& aSection) + { + TInt resourceCount=iSession->ResourceCount(); + INFO_PRINTF2(_L("RFbsSession::ResourceCount() %d"), resourceCount); + + + // get expected difference from parameters + TInt expectedDifference; + if ( GetIntFromConfig(aSection, KExpectedDiff(), expectedDifference) ) + { + TInt actualDifference=resourceCount-iResourceCount; + if ( actualDifference != expectedDifference ) + { + ERR_PRINTF3(_L("Resource count difference is not as expected! expected: %d, actual: %d"), expectedDifference, actualDifference); + SetBlockResult(EFail); + } + } + + iResourceCount = resourceCount; + } + + +/** RFbsSession::SendCommand() call */ +void CT_DataFbsSession::DoCmdSendCommandL(const TDesC& aSection) + { + INFO_PRINTF1(_L("RFbsSession::SendCommand() call")); + + TInt fbsParameter0=0; + CFbsBitmap* fbsBitmap=NULL; + if ( CT_GraphicsUtil::GetFbsBitmapL(*this, aSection, KBitmap(), fbsBitmap) ) + { + fbsParameter0=fbsBitmap->Handle(); + } + else + { + GetIntFromConfig(aSection, KFbsParameter0(), fbsParameter0); + } + + TInt fbsParameter1=0; + GetIntFromConfig(aSection, KFbsParameter1(), fbsParameter1); + + TInt fbsParameter2=0; + GetIntFromConfig(aSection, KFbsParameter2(), fbsParameter2); + + TInt fbsParameter3=0; + GetIntFromConfig(aSection, KFbsParameter3(), fbsParameter3); + + TInt fbsMessage; + if ( !GetFbsMessage(aSection, fbsMessage) ) + { + ERR_PRINTF1(_L("No fbs message")); + SetBlockResult(EFail); + } + else + { + iSession->SendCommand(fbsMessage, fbsParameter0, fbsParameter1, fbsParameter2, fbsParameter3); + } + } + + +/** RFbsSession::Version() call */ +void CT_DataFbsSession::DoCmdVersion(const TDesC& aSection) + { + INFO_PRINTF1(_L("RFbsSession::Version() call")); + + TVersion version = iSession->Version(); + TVersionName versionName = version.Name(); + INFO_PRINTF2(_L("Version name : %s"), &versionName); + INFO_PRINTF2(_L("Version build : %d"), (TInt)version.iBuild); + INFO_PRINTF2(_L("Version major : %d"), (TInt)version.iMajor); + INFO_PRINTF2(_L("Version minor : %d"), (TInt)version.iMinor); + + TPtrC name; + if ( GetStringFromConfig(aSection, KVersionName(), name) ) + { + if ( name != version.Name() ) + { + ERR_PRINTF1(_L("Name does not match expected name")); + SetBlockResult(EFail); + } + } + + TInt intTemp; + if ( GetIntFromConfig(aSection, KVersionBuild(), intTemp) ) + { + if ( intTemp != version.iBuild ) + { + ERR_PRINTF1(_L("Build does not match expected build")); + SetBlockResult(EFail); + } + } + + if ( GetIntFromConfig(aSection, KVersionMajor(), intTemp) ) + { + if ( intTemp != version.iMajor ) + { + ERR_PRINTF1(_L("Major does not match expected major")); + SetBlockResult(EFail); + } + } + + if ( GetIntFromConfig(aSection, KVersionMinor(), intTemp) ) + { + if ( intTemp != version.iMinor ) + { + ERR_PRINTF1(_L("Minor does not match expected minor")); + SetBlockResult(EFail); + } + } + + if (version.Name() == _L("") && version.iBuild == 0 && version.iMajor == 0 && version.iMinor == 0) + { + ERR_PRINTF1(_L("Some version fields are not set!")); + SetBlockResult(EFail); + } + } + + +/** RFbsSession::HeapBase() call */ +void CT_DataFbsSession::DoCmdHeapBase() + { + TUint8* heapBase = iSession->HeapBase(); + INFO_PRINTF2(_L("RFbsSession::HeapBase() %d"), heapBase); + + if (heapBase == NULL) + { + ERR_PRINTF1(_L("Heap base is null!")); + SetBlockResult(EFail); + } + } + + +/** RFbsSession::SessionHandle() call */ +void CT_DataFbsSession::DoCmdSessionHandle() + { + TInt sessionHandle = iSession->SessionHandle(); + INFO_PRINTF2(_L("RFbsSession::SessionHandle() %d"), sessionHandle); + + if (sessionHandle == 0) + { + ERR_PRINTF1(_L("Session handle is 0!")); + SetBlockResult(EFail); + } + } + + +/** +* Return a pointer to the object that the data wraps. Not implemented, returns NULL. +* +* @return pointer to the object that the data wraps. Not implemented, returns NULL. +*/ +TAny* CT_DataFbsSession::GetObject() + { + return iSession; + } + + +/** Function used as a call back, that sets GlobalCallBackCalled to true*/ +TInt CT_DataFbsSession::CallBackFunction(TAny* aThis) + { + return static_cast(aThis)->CallBackFunction(); + } + + +/** Function used as a call back, that sets GlobalCallBackCalled to true*/ +TInt CT_DataFbsSession::CallBackFunction() + { + return iCallBackCalled = ETrue; + } + +TBool CT_DataFbsSession::GetFbsMessage(const TDesC& aSection, TInt& aMessage) + { + TPtrC fbsMessage; + TBool ret=GetStringFromConfig(aSection, KFbsMessage(), fbsMessage); + if ( !ret ) + { + ERR_PRINTF2(_L("No %S"), &KFbsMessage()); + SetBlockResult(EFail); + } + else + { + if ( fbsMessage==KFbsMessInit ) + { + aMessage = EFbsMessInit; + } + else if ( fbsMessage==KFbsMessShutdown ) + { + aMessage = EFbsMessShutdown; + } + else if ( fbsMessage==KFbsMessClose ) + { + aMessage = EFbsMessClose; + } + else if ( fbsMessage==KFbsMessResourceCount ) + { + aMessage = EFbsMessResourceCount; + } + else if ( fbsMessage==KFbsMessNumTypefaces ) + { + aMessage = EFbsMessNumTypefaces; + } + else if ( fbsMessage==KFbsMessTypefaceSupport ) + { + aMessage = EFbsMessTypefaceSupport; + } + else if ( fbsMessage==KFbsMessFontHeightInTwips ) + { + aMessage = EFbsMessFontHeightInTwips; + } + else if ( fbsMessage==KFbsMessFontHeightInPixels ) + { + aMessage = EFbsMessFontHeightInPixels; + } + else if ( fbsMessage==KFbsMessAddFontStoreFile ) + { + aMessage = EFbsMessAddFontStoreFile; + } + else if ( fbsMessage==KFbsMessInstallFontStoreFile ) + { + aMessage = EFbsMessInstallFontStoreFile; + } + else if ( fbsMessage==KFbsMessRemoveFontStoreFile ) + { + aMessage = EFbsMessRemoveFontStoreFile; + } + else if ( fbsMessage==KFbsMessSetPixelHeight ) + { + aMessage = EFbsMessSetPixelHeight; + } + else if ( fbsMessage==KFbsMessGetFontById ) + { + aMessage = EFbsMessGetFontById; + } + else if ( fbsMessage==KFbsMessFontDuplicate ) + { + aMessage = EFbsMessFontDuplicate; + } + else if ( fbsMessage==KFbsMessBitmapCreate ) + { + aMessage = EFbsMessBitmapCreate; + } + else if ( fbsMessage==KFbsMessBitmapResize ) + { + aMessage = EFbsMessBitmapResize; + } + else if ( fbsMessage==KFbsMessBitmapDuplicate ) + { + aMessage = EFbsMessBitmapDuplicate; + } + else if ( fbsMessage==KFbsMessBitmapLoad ) + { + aMessage = EFbsMessBitmapLoad; + } + else if ( fbsMessage==KFbsMessDefaultAllocFail ) + { + aMessage = EFbsMessDefaultAllocFail; + } + else if ( fbsMessage==KFbsMessDefaultMark ) + { + aMessage = EFbsMessDefaultMark; + } + else if ( fbsMessage==KFbsMessDefaultMarkEnd ) + { + aMessage = EFbsMessDefaultMarkEnd; + } + else if ( fbsMessage==KFbsMessUserAllocFail ) + { + aMessage = EFbsMessUserAllocFail; + } + else if ( fbsMessage==KFbsMessUserMark ) + { + aMessage = EFbsMessUserMark; + } + else if ( fbsMessage==KFbsMessUserMarkEnd ) + { + aMessage = EFbsMessUserMarkEnd; + } + else if ( fbsMessage==KFbsMessHeapCheck ) + { + aMessage = EFbsMessHeapCheck; + } + else if ( fbsMessage==KFbsMessRasterize ) + { + aMessage = EFbsMessRasterize; + } + else if ( fbsMessage==KFbsMessFaceAttrib ) + { + aMessage = EFbsMessFaceAttrib; + } + else if ( fbsMessage==KFbsMessHasCharacter ) + { + aMessage = EFbsMessHasCharacter; + } + else if ( fbsMessage==KFbsMessSetDefaultGlyphBitmapType ) + { + aMessage = EFbsMessSetDefaultGlyphBitmapType; + } + else if ( fbsMessage==KFbsMessGetDefaultGlyphBitmapType ) + { + aMessage = EFbsMessGetDefaultGlyphBitmapType; + } + else if ( fbsMessage==KFbsMessFontNameAlias ) + { + aMessage = EFbsMessFontNameAlias; + } + else if ( fbsMessage==KFbsMessBitmapCompress ) + { + aMessage = EFbsMessBitmapCompress; + } + else if ( fbsMessage==KFbsMessGetHeapSizes ) + { + aMessage = EFbsMessGetHeapSizes; + } + else if ( fbsMessage==KFbsMessGetNearestFontToDesignHeightInTwips ) + { + aMessage = EFbsMessGetNearestFontToDesignHeightInTwips; + } + else if ( fbsMessage==KFbsMessGetNearestFontToMaxHeightInTwips ) + { + aMessage = EFbsMessGetNearestFontToMaxHeightInTwips; + } + else if ( fbsMessage==KFbsMessGetNearestFontToDesignHeightInPixels ) + { + aMessage = EFbsMessGetNearestFontToDesignHeightInPixels; + } + else if ( fbsMessage==KFbsMessGetNearestFontToMaxHeightInPixels ) + { + aMessage = EFbsMessGetNearestFontToMaxHeightInPixels; + } + else if ( fbsMessage==KFbsMessShapeText ) + { + aMessage = EFbsMessShapeText; + } + else if ( fbsMessage==KFbsMessShapeDelete ) + { + aMessage = EFbsMessShapeDelete; + } + else if ( fbsMessage==KFbsMessDefaultLanguageForMetrics ) + { + aMessage = EFbsMessDefaultLanguageForMetrics; + } + else if ( fbsMessage==KFbsMessSetTwipsHeight ) + { + aMessage = EFbsMessSetTwipsHeight; + } + else if ( fbsMessage==KFbsMessGetTwipsHeight ) + { + aMessage = EFbsMessGetTwipsHeight; + } + else if ( fbsMessage==KFbsCompress ) + { + aMessage = EFbsCompress; + } + else if ( fbsMessage==KFbsMessBitmapBgCompress ) + { + aMessage = EFbsMessBitmapBgCompress; + } + + else if ( fbsMessage==KFbsSetSystemDefaultTypefaceName ) + { + aMessage = EFbsSetSystemDefaultTypefaceName; + } + else if ( fbsMessage==KFbsGetAllBitmapHandles ) + { + aMessage = EFbsGetAllBitmapHandles; + } + else if ( fbsMessage==KFbsMessCreateLinkedTypeface ) + { + aMessage = EFbsMessCreateLinkedTypeface; + } + else if ( fbsMessage==KFbsMessSetHeapFail ) + { + aMessage = EFbsMessSetHeapFail; + } + else if ( fbsMessage==KFbsMessHeapCount ) + { + aMessage = EFbsMessHeapCount; + } + else if ( fbsMessage==KFbsMessSetHeapReset ) + { + aMessage = EFbsMessSetHeapReset; + } + else if ( fbsMessage==KFbsMessSetHeapCheck ) + { + aMessage = EFbsMessSetHeapCheck; + } + else if ( fbsMessage==KFbsMessHeap ) + { + aMessage = EFbsMessHeap; + } + else if ( fbsMessage==KFbsMessLinkedCache ) + { + aMessage = EFbsMessLinkedCache; + } + else if ( fbsMessage==KFbsMessBitmapClean ) + { + aMessage = EFbsMessBitmapClean; + } + else + { + ret=GetIntFromConfig(aSection, KFbsMessage(), aMessage); + } + } + + return ret; + }