MCL/sf/os/textandloc: comparison fontservices/fontstore/src/OPENFONT.CPP

equal deleted inserted replaced

-:1fb32624e06b
+:e96e8a131979
 const TInt KSessionCacheEntries = 512;
 const TInt KDefaultSlantFactor = 20480;
 const TInt KOneIn16Dot16FixedPointFormat = 65536;
-#ifdef FNTSTORE_SUPPORT_FMM
+template<class T>
-class TPointerArrayBaseOffset
+ROffsetArray<T>::ROffsetArray()
-	{
+: iOffset(0), iCount(0)
-public:
+{}
-	TInt iCount;
-	TAny** iEntries;
+template<class T>
-	TInt iAllocated;
+TInt ROffsetArray<T>::Create(RHeap* aHeap, TInt aCount)
-	TInt iGranularity;
+{
-	};
+if (iOffset != 0)
+{
-/*RArrayGlyphEntries*/
+return KErrAlreadyExists;
+}
-inline const COpenFontGlyphTreeEntry& RArrayGlyphEntries::operator[](TInt anIndex) const
+TAny* p = aHeap->AllocZ(aCount * sizeof(TInt));
-	{
+if (p == NULL)
-	return *Entry(anIndex);
+{
-	}
+return KErrNoMemory;
+}
-inline COpenFontGlyphTreeEntry& RArrayGlyphEntries::operator[](TInt anIndex)
+iOffset = (TInt)p - (TInt)this;
-	{
+iCount = aCount;
-	return *const_cast<COpenFontGlyphTreeEntry*>(Entry(anIndex));
+return KErrNone;
-	}
+}
-inline const COpenFontGlyphTreeEntry* RArrayGlyphEntries::Entry(TInt anIndex) const
+template<class T>
-	{
+void ROffsetArray<T>::Close(RHeap* aHeap)
-	return reinterpret_cast<const COpenFontGlyphTreeEntry*>(PtrAdd(EntryMemberOffSet()[anIndex],reinterpret_cast<TInt>(this)));
+{
-	}
+if (iOffset != 0)
+{
-inline COpenFontGlyphTreeEntry** RArrayGlyphEntries::EntryMemberOffSet() const
+aHeap->Free(PtrAdd(this, iOffset));
-	{
+}
-	return reinterpret_cast<COpenFontGlyphTreeEntry**>(iEntriesOffset+reinterpret_cast<TInt>(this));
+iOffset = 0;
-	}
+iCount = 0;
+}
-inline TAny** RArrayGlyphEntries::EntryMember() const
-	{
+template<class T>
-	return reinterpret_cast<const TPointerArrayBaseOffset*>(this)->iEntries;
+TInt ROffsetArray<T>::Count() const
-	}
+{
+return iCount;
-TInt RArrayGlyphEntries::Append(COpenFontGlyphTreeEntry& anEntry)
+}
-	{
-	TInt err = RArray<TInt>::Append(reinterpret_cast<TInt>(&anEntry)-reinterpret_cast<TInt>(this));
+template<class T>
-	if (err == KErrNone)
+T* ROffsetArray<T>::operator[](TInt aIndex) const
-		{
+{
-		iEntriesOffset=reinterpret_cast<TInt>(EntryMember())-reinterpret_cast<TInt>(this);
+TInt e = ((TInt*)PtrAdd(this, iOffset))[aIndex];
-		}
+return e != 0 ? (T*)PtrAdd(this, e) : NULL;
-	return err;
+}
-	}
-#endif // FNTSTORE_SUPPORT_FMM
+template<class T>
+void ROffsetArray<T>::SetAt(TInt aIndex, T* aEntry)
+{
+((TInt*)PtrAdd(this, iOffset))[aIndex] = aEntry ? (TInt)aEntry - (TInt)this : 0;
+}
 /*COpenFontGlyphCache*/
 TShapeHeader* COpenFontGlyphCache::SearchShaperCache(TInt aSessionHandle, TFontShapeFunctionParameters*& aParams)
 	{
 	TInt heapSizeBefAloc = 0;
 	aHeap->AllocSize(heapSizeBefAloc);
 	COpenFontShaperCacheEntry* new_entry;
 	new_entry = COpenFontShaperCacheEntry::New(aHeap, aInput, aShapeHeader);
-	if (new_entry)
+	if (new_entry != NULL)
 		{
 		// increase the reference count for this
 		TInt ret=new_entry->IncRefCount(aSessionHandle);
 		if (ret != KErrNone)
 			{
 	return 0;
 	}
 TInt COpenFont::DecrementCachedRefCount(TInt aSessionHandle, TShapeHeader* aShapeHeader, TBool aResetAll)
 	{
-#ifdef FNTSTORE_SUPPORT_FMM
 	COpenFontShaperCacheEntry* ptr=NULL;
 	COpenFontGlyphCache* glyphCache=GetGlyphCache();
-	if (glyphCache)
+	if (glyphCache != NULL)
 		ptr=glyphCache->iShaperCacheSentinel;
-	if (!ptr)
+	if (ptr == NULL)
 		return KErrNone;
-#else
-	if (!iGlyphCache || !(iGlyphCache->iShaperCacheSentinel))
-		return KErrNone;
-	COpenFontShaperCacheEntry* ptr=iGlyphCache->iShaperCacheSentinel;
-	COpenFontGlyphCache* glyphCache=iGlyphCache;
-#endif // FNTSTORE_SUPPORT_FMM
 	TInt ret = KErrNotFound;
 	CFontStore* thisFontStore = File()->GetFontStore();
 	TInt allocBefDec = 0;
 	TInt allocAfterDec = 0;
 	TInt deletedBytes = 0;
 	// loop through the cache entry to decrement the ref count for a particular session
-	while (ptr->iNext)
+	while (ptr->iNext != NULL)
 		{
 		if (aResetAll)
 			{
 			// we want to reset any cache that has a matching the session handle
 			// i.e. here we dont care about which TShapeHeader and hence we can
 			glyphCache->iShapingInfoCacheMemory -= deletedBytes;
 			thisFontStore->SetShaperCacheMemUsage(thisFontStore->GetShaperCacheMemUsage() - deletedBytes);
 			ret=KErrNone;
 			}
-		else if (ptr->iShapeHeader && ptr->iShapeHeader==aShapeHeader)
+		else if (ptr->iShapeHeader != NULL && ptr->iShapeHeader==aShapeHeader)
 			{
 			// Always update the memory usage of the cache as decreasing the ref count
 			// releases memory
 			iHeap->AllocSize(allocBefDec);
 							}
 						}
 					j++;
 					}
 				i++;
-				}
+}
-			}
+}
-		// If deleted bytes are still less than the required one delete from this font
+// If deleted bytes are still less than the required one delete from this font
-#ifdef FNTSTORE_SUPPORT_FMM
+COpenFontGlyphCache* glyphCache = GetGlyphCache();
-		COpenFontGlyphCache* glyphCache = GetGlyphCache();
+if (glyphCache != NULL)
-#else
+{
-		COpenFontGlyphCache* glyphCache = iGlyphCache;
+while (totalDeletedBytes < aBytesNeeded && !glyphCache->ShaperCacheIsEmpty())
-#endif // FNTSTORE_SUPPORT_FMM
+{
-		while (totalDeletedBytes < aBytesNeeded && !glyphCache->ShaperCacheIsEmpty())
+tempDeletedBytes = glyphCache->DeleteLeastRecentlyUsedEntry(iHeap);
-			{
+if (tempDeletedBytes == 0)
-			tempDeletedBytes = glyphCache->DeleteLeastRecentlyUsedEntry(iHeap);
+break;
-			if ( tempDeletedBytes == 0)
+totalDeletedBytes += tempDeletedBytes;
-				break;
+}
-			totalDeletedBytes += tempDeletedBytes;
+}   //if(glyphCache)
-			}
+}   //if(aBytesNeeded <= KMaxShaperSesssionCacheMemory)
-		}
 	// Update the global CFontStore cache memory count
 	if (totalDeletedBytes > 0)
 		{
 		thisFontStore->SetShaperCacheMemUsage(thisFontStore->GetShaperCacheMemUsage() - totalDeletedBytes);
 	input.iFlags = 0;
 	input.iSessionHandle = aSessionHandle;
 	input.iReserved1 = 0;
 	CFontStore* thisFontStore = File()->GetFontStore();
-	// Create the glyph cache if it doesnt already exist.
+	// Create the glyph cache if it doesn't already exist.
-	// This call can only come from FBSERV
+// This call can only come from FBSERV
-	if (iGlyphCache == NULL)
+COpenFontGlyphCache* glyphCache = GetGlyphCache();
-		{
+if (glyphCache == NULL)
-		iGlyphCache = (COpenFontGlyphCache*)iHeap->Alloc(sizeof(COpenFontGlyphCache));
+{
-		if (iGlyphCache == NULL) // no memory
+glyphCache = (COpenFontGlyphCache*) iHeap->Alloc(sizeof(COpenFontGlyphCache));
-			{
+if (glyphCache == NULL) // no memory
-			return NULL;
+{
-			}
+return NULL;
-		new(iGlyphCache) COpenFontGlyphCache;
+}
-		}
+new (glyphCache) COpenFontGlyphCache;
-	// If there is no sentinel present, i.e. new cache
+SetGlyphCache(glyphCache);
-	if (iGlyphCache->iShaperCacheSentinel == NULL)
+}
-		{
+// If there is no sentinel present, i.e. new cache
-		// Create a sentinel
+if (glyphCache->iShaperCacheSentinel == NULL)
-		iGlyphCache->iShaperCacheSentinel = COpenFontShaperCacheEntry::New(iHeap);
+{
-		if (!iGlyphCache->iShaperCacheSentinel)
+// Create a sentinel
-			{
+glyphCache->iShaperCacheSentinel = COpenFontShaperCacheEntry::New(iHeap);
-			// no memory
+if (glyphCache->iShaperCacheSentinel == NULL)
-			return NULL;
+{
-			}
+// no memory
-		iGlyphCache->iShaperCacheSentinel->iNext = iGlyphCache->iShaperCacheSentinel;
+return NULL;
-		iGlyphCache->iShaperCacheSentinel->iPrevious = iGlyphCache->iShaperCacheSentinel;
+}
-		iGlyphCache->iNumberOfShaperCacheEntries = 1;
+glyphCache->iShaperCacheSentinel->iNext = glyphCache->iShaperCacheSentinel;
-		}
+glyphCache->iShaperCacheSentinel->iPrevious = glyphCache->iShaperCacheSentinel;
+glyphCache->iNumberOfShaperCacheEntries = 1;
-	// Before inserting into this cache, check if it was empty.
+}
-	// If empty, then increment the global cache count signifying one more cache is active
-	if (iGlyphCache->ShaperCacheIsEmpty())
+// Before inserting into this cache, check if it was empty.
-		{
+// If empty, then increment the global cache count signifying one more cache is active
-		thisFontStore->IncNumShaperCaches();
+if (glyphCache->ShaperCacheIsEmpty())
-		}
+{
+thisFontStore->IncNumShaperCaches();
+}
 	TInt addedBytes = 0;
 	TShapeHeader* cached_header = NULL;
 	// Insert a new entry and return the newly inserted TShapeHeader entry
-	cached_header = iGlyphCache->Insert(aSessionHandle, iHeap, input, aShapeHeader, addedBytes);
+	cached_header = glyphCache->Insert(aSessionHandle, iHeap, input, aShapeHeader, addedBytes);
 	if (cached_header == NULL)
 		return NULL;
 	// If the memory used by all the caches is greater than KMaxShaperSesssionCacheMemory, then
 	// free some memory by releasing the same amount of memory that was just added
 	return cached_header;
 	}
 TShapeHeader* COpenFont::GetShapedData(TInt aSessionHandle, TFontShapeFunctionParameters* aParams)
 	{
-	if (iGlyphCache == NULL)
+COpenFontGlyphCache* glyphCache = GetGlyphCache();
+	if (glyphCache == NULL)
 		return NULL;
 	TShapeHeader* cachedHeader = NULL;
 	CFontStore* thisFontStore = File()->GetFontStore();
 	// Always update the memory usage of the cache as increasing the reference count of a found header uses up memory
 	TInt allocBefInc = 0;
 	TInt allocAfterInc = 0;
 	iHeap->AllocSize(allocBefInc);
-#ifdef FNTSTORE_SUPPORT_FMM
-	COpenFontGlyphCache* glyphCache = GetGlyphCache();
-#else
-	COpenFontGlyphCache* glyphCache = iGlyphCache;
-#endif // FNTSTORE_SUPPORT_FMM
 	cachedHeader = glyphCache->SearchShaperCache(aSessionHandle,aParams);
 	iHeap->AllocSize(allocAfterInc);
 	TInt addedBytes = allocAfterInc - allocBefInc;
 	glyphCache->iShapingInfoCacheMemory += addedBytes;
 @param aSessionCacheList The session cache list.
 @param aFile A pointer to the COpenFontFile object creating this COpenFont.
 e.g. when creating a COpenFont the COpenFontFile derived object would pass
 it this.
 */
-#ifdef FNTSTORE_SUPPORT_FMM
 EXPORT_C COpenFont::COpenFont(RHeap* aHeap,COpenFontSessionCacheList* aSessionCacheList,
 							  COpenFontFile* aFile):
 	iHeap(aHeap),
 	iShaper(NULL),
-	iFile(aFile),
+	iFaceIndex(0)
-	iFaceIndex(0),
-	iSessionCacheList(aSessionCacheList)
 	{
-	iStartingThis=reinterpret_cast<TInt>(this);
+SetFile(aFile);
-	}
+SetSessionCacheList(aSessionCacheList);
-#else
+	}
-EXPORT_C COpenFont::COpenFont(RHeap* aHeap,COpenFontSessionCacheList* aSessionCacheList, COpenFontFile* aFile)
-:	iHeap(aHeap),
-	iShaper(NULL),
-	iFile(aFile),
-	iFaceIndex(0),
-	iSessionCacheList(aSessionCacheList),
-	iReserved(NULL)
-	{
-	}
-#endif // FNTSTORE_SUPPORT_FMM
 /**
 C++ constructor taking shared heap, session cache list, font file and face
 index as parameters.
 @param aFile A pointer to the COpenFontFile object creating this COpenFont.
 e.g. when creating a COpenFont the COpenFontFile derived object would pass
 it this.
 @param aFaceIndex The index of the typeface within the font file aFile.
 */
-#ifdef FNTSTORE_SUPPORT_FMM
 EXPORT_C COpenFont::COpenFont(RHeap* aHeap,COpenFontSessionCacheList* aSessionCacheList, COpenFontFile* aFile,TInt aFaceIndex) :
 	iHeap(aHeap),
 	iShaper(NULL),
-	iFile(aFile),
+	iFaceIndex(aFaceIndex)
-	iFaceIndex(aFaceIndex),
+	{
-	iSessionCacheList(aSessionCacheList)
+SetFile(aFile);
-	{
+SetSessionCacheList(aSessionCacheList);
-	iStartingThis=reinterpret_cast<TInt>(this);
+	}
-	}
-#else
-EXPORT_C COpenFont::COpenFont(RHeap* aHeap,COpenFontSessionCacheList* aSessionCacheList, COpenFontFile* aFile,TInt aFaceIndex)
-:	iHeap(aHeap),
-	iShaper(NULL),
-	iFile(aFile),
-	iFaceIndex(aFaceIndex),
-	iSessionCacheList(aSessionCacheList),
-	iReserved(NULL)
-	{
-	}
-#endif // FNTSTORE_SUPPORT_FMM
 /**
 Destructor
 This function frees all memory owned by the object, including the session
 	//Delete the shaper
 	delete iShaper;
 	File()->GetFontStore()->CleanupCacheOnOpenFontRemoval(this);
-	if (iGlyphCache)
+	COpenFontGlyphCache* glyphCache = GetGlyphCache();
+	if (glyphCache != NULL)
 		{
 		COpenFontGlyphTreeEntry* next = NULL;
-#ifdef FNTSTORE_SUPPORT_FMM
+		for (COpenFontGlyphTreeEntry* g = glyphCache->iGlyphList; g != NULL; g = next)
-		TInt ii;
-		RArrayGlyphEntries& glyphArray=iGlyphCache->iGlyphArray;
-		for (ii=glyphArray.Count()-1;ii>=0;--ii)
-			{
-			next=&glyphArray[ii];
-			COpenFontGlyph::Delete(iHeap,next);
-			}
-		iGlyphCache->iGlyphArray.Close();
-#else
-		for (COpenFontGlyphTreeEntry* g = iGlyphCache->iGlyphList; g; g = next)
 			{
 			next = g->iNext;
 			COpenFontGlyph::Delete(iHeap, g);
 			}
-#endif // FNTSTORE_SUPPORT_FMM
 		// Delete the shaper cache as well
-		if (iGlyphCache->iShaperCacheSentinel)
+		if (glyphCache->iShaperCacheSentinel)
 			{
 			COpenFontShaperCacheEntry* previous  = NULL;
-			COpenFontShaperCacheEntry* si = iGlyphCache->iShaperCacheSentinel->iPrevious;
+			COpenFontShaperCacheEntry* si = glyphCache->iShaperCacheSentinel->iPrevious;
 			TInt heapBefore = 0;
 			TInt heapAfter = 0;
 			iHeap->AllocSize(heapBefore);
-			while (iGlyphCache->iNumberOfShaperCacheEntries > 0)
+			while (glyphCache->iNumberOfShaperCacheEntries > 0)
 				{
 				previous = si->iPrevious;
 				COpenFontShaperCacheEntry::Delete(iHeap, si);
 				si = previous;
-				iGlyphCache->iNumberOfShaperCacheEntries--;
+				glyphCache->iNumberOfShaperCacheEntries--;
 				}
 			iHeap->AllocSize(heapAfter);
 			File()->GetFontStore()->SetShaperCacheMemUsage(File()->GetFontStore()->GetShaperCacheMemUsage() - (heapBefore - heapAfter));
 			File()->GetFontStore()->DecNumShaperCaches();
 			}
-		iHeap->Free(iGlyphCache);
+		iHeap->Free(glyphCache);
 		}
-	if (iSessionCacheList)
+	COpenFontSessionCacheList* sessionCacheList = SessionCacheList();
-		iSessionCacheList->DeleteFontGlyphs(iHeap, this);
+if (sessionCacheList != NULL)
-	if (iFile)
+{
-		iFile->RemoveFontFromList(this);
+sessionCacheList->DeleteFontGlyphs(iHeap, this);
+}
+COpenFontFile* file = File();
+if (file != NULL)
+{
+file->RemoveFontFromList(this);
+}
 	}
 COpenFontGlyph::~COpenFontGlyph()
 	{
 	}
 void COpenFontGlyph::Delete(RHeap* aHeap, COpenFontGlyph* aGlyph)
 	{
-	if (aGlyph)
+	if (aGlyph != NULL)
 		{
-#ifdef FNTSTORE_SUPPORT_FMM
 		aHeap->Free(aGlyph->Bitmap());
-#else
-		aHeap->Free(aGlyph->iBitmap);
-#endif // FNTSTORE_SUPPORT_FMM
 		aHeap->Free(aGlyph);
 		}
 	}
 EXPORT_C void COpenFont::operator delete(TAny *aFont)
 	{
-	if(aFont)
+	if(aFont != NULL)
 		{
 		COpenFont* f = (COpenFont*)aFont;
 		if (f->iHeap)
 			f->iHeap->Free(aFont);
 		}
 @return
 	ETrue if aGlyphData contains valid data (that is, if aGlyphData->Bitmap()
 	and aGlyphData->Metrics() are valid), EFalse otherwise.
 */
-#ifdef FNTSTORE_SUPPORT_FMM
 TBool COpenFont::Rasterize(TInt aSessionHandle, TInt aCode,
 	TOpenFontGlyphData* aGlyphData)
 	{
 	// create the cache if it doesn't exisit. As this call can only come from
 	// FBSERV if the chunk has to be resized then no panic will happen.
-	if (iGlyphCache == NULL)
+COpenFontGlyphCache* glyphCache = GetGlyphCache();
-		{
+	if (glyphCache == NULL)
-		iGlyphCache = (COpenFontGlyphCache*)iHeap->Alloc(sizeof(COpenFontGlyphCache));
+		{
-		if (iGlyphCache == NULL) // no memory
+glyphCache = (COpenFontGlyphCache*)iHeap->Alloc(sizeof(COpenFontGlyphCache));
+		if (glyphCache == NULL) // no memory
 			{
 			return EFalse;
 			}
-		new(iGlyphCache) COpenFontGlyphCache;
+		new(glyphCache) COpenFontGlyphCache;
+		SetGlyphCache(glyphCache);
 		}
 	// Look in the Font Cache
 	TInt* nodeInsertPtr = NULL;
 	const COpenFontGlyph* g = FontCacheGlyph(aCode, nodeInsertPtr);
 	// If it is not found there look in the session cache.
 	COpenFontSessionCache* cache = NULL;
 	TInt index = 0;
-	if (!g)
+	if (g == NULL)
 		{
 		g = SessionCacheGlyph(iHeap, aSessionHandle, aCode, cache, index, EFalse);
 		}
 	// If it has already been rasterized return it.
-	if (g)
+	if (g != NULL)
 		{
-		if (aGlyphData)
+		if (aGlyphData != NULL)
 			{
 			aGlyphData->SetMetricsPointer(&g->iMetrics);
 			aGlyphData->SetBitmapPointer(g->Bitmap());
 			}
 	const TOpenFontGlyphData* cur_glyph_data = temp_glyph_data ? temp_glyph_data : aGlyphData;
 	const COpenFontGlyph* new_glyph = NULL;
 	// If the maximum per-font cache memory will not be exceeded, put the glyph into the font cache.
 	TInt bytes = sizeof(COpenFontGlyphTreeEntry) + cur_glyph_data->BytesNeeded();
-	if(iGlyphCache && bytes + iGlyphCache->iGlyphCacheMemory <= KMaxGlyphCacheMemory)
+	if(glyphCache != NULL && bytes + glyphCache->iGlyphCacheMemory <= KMaxGlyphCacheMemory)
 		{
 		COpenFontGlyphTreeEntry* new_entry = COpenFontGlyphTreeEntry::New(iHeap, aCode, cur_glyph_data->GlyphIndex(), *cur_glyph_data->Metrics(), cur_glyph_data->Bitmap());
 		new_glyph=new_entry;
-		if(new_entry)
+		if (new_entry != NULL)
-			{
+{
-			// Insert new entry into the delete list
+// Add the glyph to a leaf node using the nodeInsertPtr that was returned by FontCacheGlyph()
-			error = iGlyphCache->iGlyphArray.Append(*new_entry);
+// This is the first node if the glyph cache is empty. This updates the cache atomically.
-			if (error == KErrNone)
+*nodeInsertPtr = PointerToThisOffset(new_entry);
-				{
-				if(!iGlyphCache->iGlyphTreeOffset)
+// If new_entry is not the first in the cache, set the previous
-					{
+// entry to link to this so that a linked-list of entries can be
-					// First entry in tree
+// maintained to simplify deletion.
-					iGlyphCache->iGlyphTreeOffset = PointerToThisOffset(new_entry);
+COpenFontGlyphTreeEntry* tree = static_cast<COpenFontGlyphTreeEntry*> (ThisOffsetToPointer(glyphCache->iGlyphTreeOffset));
-					}
+if (new_entry != tree)
-				else if (nodeInsertPtr)
+{
-					{
+while (tree->iNext != NULL)
-					// Add the glyph to a leaf node using the nodeInsertPtr that was returned by FontCacheGlyph()
+{
-					*nodeInsertPtr = PointerToThisOffset(new_entry);
+tree = tree->iNext;
-					}
+}
-				else
+tree->iNext = new_entry;
-					{
+}
-					// Failed to add the glyph to the glyph tree, remove it from the delete array.
+else
-					// (The glyph is deleted below).
+{
-					iGlyphCache->iGlyphArray.Remove(iGlyphCache->iGlyphArray.Count()-1);
+// First entry in tree, initialise iGlyphList
-					error = KErrGeneral;
+glyphCache->iGlyphList = new_entry;
-					}
+}
-				}
-			if (error != KErrNone)
+glyphCache->iGlyphCacheMemory += bytes;
-				{
+}//if (new_entry)
-				COpenFontGlyph::Delete(iHeap,new_entry);
-				}
-			else
-				{
-				iGlyphCache->iGlyphCacheMemory += bytes;
-				}
-			}
 		}
 	else
 		{
 		error = KErrGeneral;
 		}
 	// Otherwise put the glyph into the per-session cache.
 	if (error != KErrNone)
 		{
 		// If the session cache is not yet known find it or create one.
-		if (!cache)
+		if (cache == NULL)
 			{
 			SessionCacheGlyph(iHeap, aSessionHandle, aCode, cache, index, TRUE);
 			}
-		if (!cache)
+		if (cache == NULL)
 			{
 			return EFalse;
 			}
 		COpenFontSessionCacheEntry* new_entry =
 			COpenFontSessionCacheEntry::New(iHeap, this, aCode, cur_glyph_data->GlyphIndex(), *cur_glyph_data->Metrics(), cur_glyph_data->Bitmap());
 		new_glyph = new_entry;
-		if (new_entry)
+		if (new_entry != NULL)
 			{
 			cache->Insert(iHeap, new_entry, index);
 			}
 		}
-	if (temp_glyph_data)
+	if (temp_glyph_data != NULL)
 		{
 		iHeap->Free(temp_glyph_data);
 }
 // Fix up the returned glyph data pointers to point to the actual data.
-if (!new_glyph)
+if (new_glyph == NULL)
-glyph_data_valid = FALSE;
+glyph_data_valid = EFalse;
-else if (aGlyphData)
+else if (aGlyphData != NULL)
 {
 aGlyphData->SetMetricsPointer(&new_glyph->iMetrics);
 aGlyphData->SetBitmapPointer(new_glyph->Bitmap());
 }
 	return glyph_data_valid;
 	}
-#else
-TBool COpenFont::Rasterize(TInt aSessionHandle, TInt aCode,
-	TOpenFontGlyphData* aGlyphData)
-	{
-	// First look in the font cache.
-	COpenFontGlyphTreeEntry** node_ptr = NULL;
-	// create the cache if it doesn't exisit. As this call can only come from
-	// FBSERV if the chunk has to be resized then no panic will happen.
-	if (iGlyphCache == NULL)
-		{
-		iGlyphCache = (COpenFontGlyphCache*)iHeap->Alloc(sizeof(COpenFontGlyphCache));
-		if (iGlyphCache == NULL) // no memory
-			{
-			return FALSE;
-			}
-		new(iGlyphCache) COpenFontGlyphCache;
-		}
-	// Look in the fontcache. Do not expect to find a glyph here. However,
-	// it is called again so that a node pointer is found where the new glyph
-	// will be placed when added to the font cache.
-	const COpenFontGlyph* glyph = FontCacheGlyph(aCode, node_ptr);
-	if (glyph)
-		{
-		// Do not expect it to get here, since the font cache has already been searched client-side,
-		// prior to calling Rasterize(). However, just in case it does find a match, use it.
-		if (aGlyphData)
-			{
-			aGlyphData->SetMetricsPointer(&glyph->iMetrics);
-			aGlyphData->SetBitmapPointer(glyph->iBitmap);
-			}
-		return TRUE;
-		}
-	// Rasterize the glyph.
-	TOpenFontGlyphData* temp_glyph_data = NULL;
-	TInt error = KErrNone;
-	TRAP(error, RasterizeHelperL(aCode, aGlyphData, temp_glyph_data));
-	if (error)
-		{
-		iHeap->Free(temp_glyph_data);
-		return FALSE;
-		}
-	TBool glyph_data_valid = TRUE;
-	const TOpenFontGlyphData* cur_glyph_data = temp_glyph_data ? temp_glyph_data : aGlyphData;
-	const COpenFontGlyph* new_glyph = NULL;
-	// If the maximum per-font cache memory will not be exceeded, put the glyph into the font cache.
-	TInt bytes = sizeof(COpenFontGlyphTreeEntry) + cur_glyph_data->BytesNeeded();
-	if (iGlyphCache && node_ptr && bytes + iGlyphCache->iGlyphCacheMemory <= KMaxGlyphCacheMemory)
-		{
-		COpenFontGlyphTreeEntry* new_entry = COpenFontGlyphTreeEntry::New(iHeap, aCode, cur_glyph_data->GlyphIndex(), *cur_glyph_data->Metrics(), cur_glyph_data->Bitmap());
-		new_glyph = new_entry;
-		if (new_entry)
-			{
-			*node_ptr = new_entry;	// update the cache atomically
-			// Insert new entry into the delete list
-			COpenFontGlyphTreeEntry* start = iGlyphCache->iGlyphTree;
-			COpenFontGlyphTreeEntry* tree = start;
-			if (new_entry != iGlyphCache->iGlyphTree)
-				{
-				while (tree->iNext)
-					{
-					tree = tree->iNext;
-					}
-				tree->iNext = new_entry;
-				}
-			else
-				{
-				// First entry in tree, initialise iGlyphList
-				iGlyphCache->iGlyphList = new_entry;
-				}
-			iGlyphCache->iGlyphCacheMemory += bytes;
-			}
-		}
-	// Otherwise put the glyph into the per-session cache.
-	else
-		{
-		// If the session cache is not yet known find it or create one.
-		COpenFontSessionCache* cache = NULL;
-		TInt index = 0;
-		SessionCacheGlyph(iHeap, aSessionHandle, aCode, cache, index, TRUE);
-		if (!cache)
-			return FALSE;
-		COpenFontSessionCacheEntry* new_entry =
-			COpenFontSessionCacheEntry::New(iHeap, this, aCode, cur_glyph_data->GlyphIndex(), *cur_glyph_data->Metrics(), cur_glyph_data->Bitmap());
-		new_glyph = new_entry;
-		if (new_entry)
-			cache->Insert(iHeap, new_entry, index);
-		}
-	if (temp_glyph_data)
-		{
-iHeap->Free(temp_glyph_data);
-}
-// Fix up the returned glyph data pointers to point to the actual data.
-if (!new_glyph)
-glyph_data_valid = FALSE;
-else if (aGlyphData)
-{
-aGlyphData->SetMetricsPointer(&new_glyph->iMetrics);
-aGlyphData->SetBitmapPointer(new_glyph->iBitmap);
-}
-	return glyph_data_valid;
-	}
-#endif // FNTSTORE_SUPPORT_FMM
 void COpenFont::RasterizeHelperL(TInt aCode, TOpenFontGlyphData* aGlyphData, TOpenFontGlyphData*& aTempGlyphData)
 	{
 	aTempGlyphData = 0;
 	MOpenFontShapingExtension* extensionInterface = 0;
 		// get the extension API for RasterizeGlyphL() if available
 		TAny* ext = NULL;
 		ExtendedInterface(KUidOpenFontShapingExtension, ext);
 		extensionInterface = reinterpret_cast<MOpenFontShapingExtension*>(ext);
-		if (!extensionInterface)
+		if (extensionInterface == NULL)
 			// an attempt to rasterize a glyph when the rasterizer does not
 			// support it; best to do nothing
 			return;
 		}
 	TOpenFontGlyphData* currGlyphData = aGlyphData;
-	if (!currGlyphData)
+	if (currGlyphData == NULL)
 		{
 		aTempGlyphData = TOpenFontGlyphData::New(iHeap, 0);
 		if (!aTempGlyphData)
 			User::Leave(KErrNoMemory);
 		currGlyphData = aTempGlyphData;
 		}
-	if (extensionInterface)
+	if (extensionInterface != NULL)
 		extensionInterface->RasterizeGlyphL(aCode, currGlyphData);
 	else
 		RasterizeL(aCode, currGlyphData);
 	// If the GlyphData object was not large enough, create a temporary one
 		{
 		TInt bytesNeeded = currGlyphData->BytesNeeded();
 		if (aTempGlyphData)
 			iHeap->Free(aTempGlyphData);
 		aTempGlyphData = TOpenFontGlyphData::New(iHeap, bytesNeeded);
-		if (!aTempGlyphData)
+		if (aTempGlyphData == NULL)
 			User::Leave(KErrNoMemory);
 		currGlyphData = aTempGlyphData;
 		// If the extension interface was used above, then use again here
-		if (extensionInterface)
+		if (extensionInterface != NULL)
 			extensionInterface->RasterizeGlyphL(aCode, currGlyphData);
 		else
 			RasterizeL(aCode, currGlyphData);
 		}
 ExtendedInterface(KUidOpenFontTrueTypeExtension, ext);
 MOpenFontTrueTypeExtension* extensionInterface =
 reinterpret_cast<MOpenFontTrueTypeExtension*>(ext);
 TInt ret = KErrNone;
-if (!extensionInterface)
+if (extensionInterface == NULL)
 {
 ret = KErrNotSupported;
 }
 else
 {
 ExtendedInterface(KUidOpenFontGlyphOutlineExtension, ext);
 MOpenFontGlyphOutlineExtension *extensionInterface =
 reinterpret_cast<MOpenFontGlyphOutlineExtension*>(ext);
 TInt ret = KErrNone;
-if (!extensionInterface)
+if (extensionInterface == NULL)
 {
 ret = KErrNotSupported;
 }
 else
 {
 ret = extensionInterface->GetGlyphOutline(aCode, ETrue,
 aHinted, aOutline, aLength);
 }
 return ret;
 }
-#ifdef FNTSTORE_SUPPORT_FMM
 /** Given the passed pointer aAny, return an offset from it to the "this" pointer
 of this COpenFont object.
 @param aAny A pointer to an object that exists on the shared heap, i.e. the same heap
 that this CCOpenFont object was created on.
 @return An offset relative to the "this" pointer for this object, this offset can
 @see ThisOffsetToPointer().
 @internalComponent
 */
 TInt COpenFont::PointerToThisOffset(const TAny* aAny)
 	{
-	if (aAny)
+	if (aAny != NULL)
 		{
 		return ((TInt)aAny - (TInt)this);
 		}
 	return 0;
 	}
 		{
 		return (TAny*)((TInt)this + aThisOffset);
 		}
 	return NULL;
 	}
-#endif // FNTSTORE_SUPPORT_FMM
 /**
 A constructor initialised with a TCharacterMetrics object.
 This is the old-style character metrics object. As for other T classes, there
 	aMetrics.iAscentInPixels = iHorizBearingY;
 	aMetrics.iHeightInPixels = iHeight;
 	aMetrics.iLeftAdjustInPixels = iHorizBearingX;
 	aMetrics.iMoveInPixels = iHorizAdvance;
 	aMetrics.iRightAdjustInPixels = (TInt16)(iHorizAdvance - iHorizBearingX - iWidth);
-	return TRUE;
+	return ETrue;
 	}
 TBool COpenFont::GetCharacterData(TInt aSessionHandle, TInt aCode, const TOpenFontCharMetrics*& aMetrics, const TUint8*& aBitmap) const
 	{
 	const COpenFontGlyph* g = Glyph(aSessionHandle, aCode);
-	if (g)
+	if (g != NULL)
 		{
 		aMetrics = &g->iMetrics;
-#ifdef FNTSTORE_SUPPORT_FMM
 		aBitmap = g->Bitmap();
-#else
+		return ETrue;
-		aBitmap = g->iBitmap;
-#endif // FNTSTORE_SUPPORT_FMM
-		return TRUE;
 		}
 	else
 		{
 		aMetrics = NULL;
 		aBitmap = NULL;
-		return FALSE;
+		return EFalse;
 		}
 	}
 void COpenFont::OnFileDeleted()
 	{
-	iFile = NULL;
+iFileOffset = 0;
 	}
 COpenFontGlyphCache* COpenFont::GetGlyphCache()
 	{
-#ifdef FNTSTORE_SUPPORT_FMM
+if (iGlyphCacheOffset == 0)
-	if (iGlyphCache)
+{
-		return reinterpret_cast<COpenFontGlyphCache*>(reinterpret_cast<TInt>(iGlyphCache)+Offset());
+return NULL;
-#else
+}
-	if (iGlyphCache)
+return reinterpret_cast<COpenFontGlyphCache*>(PtrAdd(this, iGlyphCacheOffset));
-		return iGlyphCache;
-#endif // FNTSTORE_SUPPORT_FMM
-	else
-		return NULL;
 	}
 const COpenFontGlyph* COpenFont::Glyph(TInt aSessionHandle, TInt aCode) const
 	{
-#ifdef FNTSTORE_SUPPORT_FMM
 	const COpenFontGlyph* glyph = const_cast<COpenFont*>(this)->FontCacheGlyph(aCode);
-	if (!glyph)
+	if (glyph == NULL)
 		{
 		COpenFontSessionCache* cache;
 		TInt index;
-		glyph = SessionCacheGlyph(iHeap, aSessionHandle, aCode, cache, index, FALSE);
+		glyph = SessionCacheGlyph(iHeap, aSessionHandle, aCode, cache, index, EFalse);
 	}
 	return glyph;
-#else
-	const COpenFontGlyph* g = CONST_CAST(COpenFont*,this)->FontCacheGlyph(aCode);
-	if (!g)
-		{
-		COpenFontSessionCache* cache;
-		TInt index;
-		g = SessionCacheGlyph(iHeap, aSessionHandle, aCode, cache, index, FALSE);
-		}
-	return g;
-#endif // FNTSTORE_SUPPORT_FMM
 	}
 /**
 Is the specified character present in the font?
 */
 TBool COpenFont::HasCharacterL(TInt aCode) const
 	{
 	COpenFontFile* file = File();
-	if (file)
+	if (file != NULL)
 		return file->HasUnicodeCharacterL(iFaceIndex, aCode);
 	else
-		return FALSE;
+		return EFalse;
 	}
-#ifdef FNTSTORE_SUPPORT_FMM
 /**
 Retrieve glyph data from the per-font glyph cache.
 If it is not found return NULL.
 If the cache hasn't been created, then return NULL.
 Previous versions of this function created the cache, but as this function can potentially
 		if (glyphCache->iGlyphTreeOffset)
 			{
 			node = static_cast<COpenFontGlyphTreeEntry*>(ThisOffsetToPointer(glyphCache->iGlyphTreeOffset));
 			}
-		while (node)
+		while (node != NULL)
 			{
 			TInt code = node->iCode;
 			if(code == aCode)
 				{
 				// Found the glyph
 	{
 	aNodeInsertPtr = NULL;
 	if (COpenFontGlyphCache* glyphCache = GetGlyphCache())
 		{
-		COpenFontGlyphTreeEntry* node = NULL;
+COpenFontGlyphTreeEntry* node = NULL;
-		if (glyphCache->iGlyphTreeOffset)
+if (glyphCache->iGlyphTreeOffset)
-			{
+{
-			node = static_cast<COpenFontGlyphTreeEntry*>(ThisOffsetToPointer(glyphCache->iGlyphTreeOffset));
+node = static_cast<COpenFontGlyphTreeEntry*> (ThisOffsetToPointer(glyphCache->iGlyphTreeOffset));
-			}
+}
+else
-		while (node)
+{
+aNodeInsertPtr = &glyphCache->iGlyphTreeOffset;
+}
+while (node != NULL)
 			{
 			TInt code = node->iCode;
 			if(code == aCode)
 				{
 				// Found the glyph
 		}
 	// No glyph found
 	return NULL;
 	}
-#else
-/**
-Retrieve glyph data from the per-font glyph cache.
-If it is not found return NULL.
-If the cache hasn't been created, then return null.
-Previous versions of this function created the cache, but as this function can potentially
-run in the context of threads other than FBSERV the alloc could panic if iHeap's chunk had to
-be resized - this is not allowed by the kernel.
-The cache is now created in COpenFont::Rasterize which can only be called within the context of FBSERV
-*/
-const COpenFontGlyph* COpenFont::FontCacheGlyph(TInt aCode)
-	{
-	if (iGlyphCache)
-		{
-		COpenFontGlyphTreeEntry* node = iGlyphCache->iGlyphTree;
-		while (node)
-			{
-			if (node->iCode == aCode)
-				return node;
-			if (node->iCode > aCode)
-				node = node->iLeft;
-			else
-				node = node->iRight;
-			}
-		}
-	return NULL;
-	}
-/**
-Retrieve glyph data from the per-font glyph cache.
-If it is not found return NULL and place the address of the node pointer
-to receive a new glyph in aNode.
-If the cache hasn't been created, then return null.
-Previous versions of this function created the cache, but as this function can potentially
-run in the context of threads other than FBSERV the alloc could panic if iHeap's chunk had to
-be resized - this is not allowed by the kernel.
-The cache is now created in COpenFont::Rasterize which can only be called within the context of FBSERV
-*/
-const COpenFontGlyph* COpenFont::FontCacheGlyph(TInt aCode, COpenFontGlyphTreeEntry**& aNode)
-	{
-	if (!iGlyphCache)
-		{
-		aNode = NULL;
-		return NULL;
-		}
-	aNode = &iGlyphCache->iGlyphTree;
-	while (*aNode)
-		{
-		if ((*aNode)->iCode == aCode)
-			return *aNode;
-		if ((*aNode)->iCode > aCode)
-			aNode = &((*aNode)->iLeft);
-		else
-			aNode = &((*aNode)->iRight);
-		}
-	return NULL;
-	}
-#endif // FNTSTORE_SUPPORT_FMM
 /** Retrieve glyph data from the session cache. If the glyph is not in the
 cache, return the cache and glyph index where the glyph data should be put. If
 there is no session cache, optionally create it.
 @param aCreate
 	If False, creation of a new cache is inhibited
 @return The glyph data, or null if the glyph is not in the cache
 @internalComponent
 */
-#ifdef FNTSTORE_SUPPORT_FMM
 const COpenFontGlyph* COpenFont::SessionCacheGlyph(RHeap* aHeap,
 	TInt aSessionHandle, TInt aCode, COpenFontSessionCache*& aCache,
 	TInt& aIndex, TBool aCreate) const
 	{
 	aIndex = 0;
 	    RDebug::Print(_L("COpenFont::SessionCacheGlyphe() can't open SessionCacheSemaphore"));
 	    return NULL;
 	    }
 	sem.Wait();
 	COpenFontSessionCacheListItem* cacheListStart=cachelist->Start();
-	if(cacheListStart)
+	if(cacheListStart != NULL)
 		{
 		for (COpenFontSessionCacheListItem* p = cacheListStart; p; p = p->Next())
 			{
 			COpenFontSessionCache* cache=p->Cache();
 			if (cache->iSessionHandle == aSessionHandle)
 	if (aCreate)
 		{
 		COpenFontSessionCache* new_cache = NULL;
 		TRAPD(error, new_cache = COpenFontSessionCache::NewL(aHeap, aSessionHandle, KSessionCacheEntries));
-		if ((!error) && new_cache)
+		if ((!error) && new_cache != NULL)
 			{
 			COpenFontSessionCacheListItem* new_item = (COpenFontSessionCacheListItem*)aHeap->Alloc(sizeof(COpenFontSessionCacheListItem));
-			if (!new_item)
+			if (new_item == NULL)
 				{
 				new_cache->Delete(aHeap);
 				aHeap->Free(new_cache);
 				return NULL;
 				}
 			new(new_item) COpenFontSessionCacheListItem(new_cache);
-			if (prev)
+			if (prev != NULL)
 				{
 				prev->SetNext(new_item);
 				}
 			else
 				{
 			aIndex = GLYPH_CODE(aCode) % KSessionCacheEntries;
 			}
 		}
 	return NULL;
 	}
-#else
-const COpenFontGlyph* COpenFont::SessionCacheGlyph(RHeap* aHeap,
+COpenFontSessionCacheList* COpenFont::SessionCacheList()const
-	TInt aSessionHandle, TInt aCode, COpenFontSessionCache*& aCache,
+{
-	TInt& aIndex, TBool aCreate) const
+if (iSessionCacheListOffset == 0)
-	{
-	aCache = NULL;
-	aIndex = 0;
-	COpenFontSessionCacheListItem* prev = NULL;
-RSemaphore sem;
-if(KErrNone != sem.OpenGlobal(KSessionCacheSemaphoreName))
 {
-RDebug::Print(_L("COpenFont::SessionCacheGlyphe() can't open SessionCacheSemaphore"));
 return NULL;
 }
-sem.Wait();
+return reinterpret_cast<COpenFontSessionCacheList*>(reinterpret_cast<TInt>(this) + iSessionCacheListOffset);
-	for (COpenFontSessionCacheListItem* p = iSessionCacheList->iStart; p; p = p->iNext)
+}
-		{
-		if (p->iCache->iSessionHandle == aSessionHandle)
+void COpenFont::SetSessionCacheList(COpenFontSessionCacheList* aSessionCacheList)
-			{
+{
-			aCache = p->iCache;
+iSessionCacheListOffset = aSessionCacheList ? reinterpret_cast<TInt>(aSessionCacheList) - reinterpret_cast<TInt>(this) : NULL;
-		    sem.Signal();
+}
-		    sem.Close();
-			return aCache->Glyph(this, aCode, aIndex);
+void COpenFont::SetFile(COpenFontFile* aFile)
-			}
+{
-		prev = p;
+iFileOffset = aFile ? reinterpret_cast<TInt>(aFile) - reinterpret_cast<TInt>(this) : NULL;
-		}
+}
-sem.Signal();
-	sem.Close();
+void COpenFont::SetGlyphCache(COpenFontGlyphCache* aGlyphCache)
+{
-	if (aCreate)
+iGlyphCacheOffset = aGlyphCache ? reinterpret_cast<TInt>(aGlyphCache) - reinterpret_cast<TInt>(this) : NULL;
-		{
+}
-		COpenFontSessionCache* new_cache = NULL;
-		TRAPD(error, new_cache = COpenFontSessionCache::NewL(aHeap, aSessionHandle, KSessionCacheEntries));
-		if ((!error) && new_cache)
-			{
-			COpenFontSessionCacheListItem* new_item = (COpenFontSessionCacheListItem*)aHeap->Alloc(sizeof(COpenFontSessionCacheListItem));
-			if (!new_item)
-				{
-				new_cache->Delete(aHeap);
-				aHeap->Free(new_cache);
-				return NULL;
-				}
-			new(new_item) COpenFontSessionCacheListItem(new_cache);
-			if (prev)
-				prev->iNext = new_item;
-			else
-				iSessionCacheList->iStart = new_item;
-			aCache = new_cache;
-			aIndex = GLYPH_CODE(aCode) % KSessionCacheEntries;
-			}
-		}
-	return NULL;
-	}
-#endif // FNTSTORE_SUPPORT_FMM
 /**
 Create a glyph data object on the shared heap, given the code, metrics and the data bytes.
 The data is copied; ownership remains with the caller.
 */
 	}
 COpenFontGlyphTreeEntry* COpenFontGlyphTreeEntry::New(RHeap* aHeap, TInt aCode, TInt aGlyphIndex, const TOpenFontCharMetrics& aMetrics, const TDesC8& aBitmap)
 	{
 	COpenFontGlyphTreeEntry* entry = (COpenFontGlyphTreeEntry*)aHeap->Alloc(sizeof(COpenFontGlyphTreeEntry));
-	if (!entry)
+	if (entry == NULL)
 		return NULL;
 	new(entry) COpenFontGlyphTreeEntry(aCode, aGlyphIndex, aMetrics);
 	if (!entry->SetBitmap(aHeap, aBitmap))
 		{
 		aHeap->Free(entry);
 	}
 COpenFontSessionCacheEntry* COpenFontSessionCacheEntry::New(RHeap* aHeap, const COpenFont* aFont, TInt aCode, TInt aGlyphIndex, const TOpenFontCharMetrics& aMetrics, const TDesC8& aBitmap)
 	{
 	COpenFontSessionCacheEntry* entry = (COpenFontSessionCacheEntry*)aHeap->Alloc(sizeof(COpenFontSessionCacheEntry));
-	if (!entry)
+	if (entry == NULL)
 		return NULL;
 	new(entry) COpenFontSessionCacheEntry(aFont, aCode, aGlyphIndex, aMetrics);
 	if (!entry->SetBitmap(aHeap, aBitmap))
 		{
 		aHeap->Free(entry);
 		entry = NULL;
 		}
 	return entry;
 	}
-#ifdef FNTSTORE_SUPPORT_FMM
-inline COpenFont* COpenFontSessionCacheEntry::Font()const
-{
-if(iFontOffset)
-{
-return reinterpret_cast<COpenFont*>(reinterpret_cast<TInt>(this) + iFontOffset);
-}
-else
-return NULL;
-}
 /**
 @return A pointer to the run-length-encoded bitmap stored with this glyph, or NULL
 if no bitmap has been stored with this glyph.
 */
 TUint8* COpenFontGlyph::Bitmap() const
 	{
 	if (iBitmapOffset)
 		{
-		return (TUint8*)((TInt)this + iBitmapOffset);
+		return reinterpret_cast<TUint8*>(reinterpret_cast<TInt>(this) + iBitmapOffset);
 		}
 	return NULL;
 	}
-#endif // FNTSTORE_SUPPORT_FMM
 TBool COpenFontGlyph::SetBitmap(RHeap* aHeap, const TDesC8& aBitmap)
 	{
 	TUint8* bitmap = (TUint8*)aHeap->Alloc(aBitmap.Length());
-	if (!bitmap)
+	if (bitmap == NULL)
-		return FALSE;
+		return EFalse;
 	Mem::Copy(bitmap, aBitmap.Ptr(), aBitmap.Length());
-#ifdef FNTSTORE_SUPPORT_FMM
 	aHeap->Free(Bitmap());
-	iBitmapOffset = (TInt)bitmap - (TInt)this;
+	iBitmapOffset = reinterpret_cast<TInt>(bitmap) - reinterpret_cast<TInt>(this);
-#else
+	return ETrue;
-	if (iBitmap)
+	}
-		aHeap->Free(iBitmap);
-	iBitmap = bitmap;
-#endif // FNTSTORE_SUPPORT_FMM
-	return TRUE;
-	}
-#ifdef FNTSTORE_SUPPORT_FMM
 COpenFontSessionCache* COpenFontSessionCache::NewL(RHeap* aHeap, TInt aSessionHandle, TInt aEntries)
 	{
-	COpenFontSessionCache* c = reinterpret_cast<COpenFontSessionCache*>(aHeap->AllocL(sizeof(COpenFontSessionCache)));
-	new(c) COpenFontSessionCache(aSessionHandle,aEntries);
-	TInt bytes = sizeof(TInt) * aEntries;
-	TInt* entry= reinterpret_cast<TInt*>(aHeap->Alloc(bytes));
-	Mem::FillZ(entry, bytes);
-	if (!entry)
-		{
-		aHeap->Free(c);
-		User::Leave(KErrNoMemory);
-		}
-	c->iEntryOffset = reinterpret_cast<TInt>(entry) - reinterpret_cast<TInt>(c);
-	return c;
-	}
-#else
-COpenFontSessionCache* COpenFontSessionCache::NewL(RHeap* aHeap, TInt aSessionHandle, TInt aEntries)
-{
 COpenFontSessionCache* c = (COpenFontSessionCache*)aHeap->AllocL(sizeof(COpenFontSessionCache));
-new(c) COpenFontSessionCache(aSessionHandle,aEntries);
+new(c) COpenFontSessionCache(aSessionHandle);
-TInt bytes = sizeof(COpenFontSessionCacheEntry*) * aEntries;
+if (c->iEntryArray.Create(aHeap, aEntries) != KErrNone)
-c->iEntry = (COpenFontSessionCacheEntry**)aHeap->Alloc(bytes);
-Mem::FillZ(c->iEntry, bytes);
-if (!c->iEntry)
 {
 aHeap->Free(c);
 User::Leave(KErrNoMemory);
 }
 return c;
-}
+	}
-#endif //FNTSTORE_SUPPORT_FMM
-#ifdef FNTSTORE_SUPPORT_FMM
 void COpenFontSessionCache::Delete(RHeap* aHeap)
 {
-TInt* e =Entry();
+TInt entries = iEntryArray.Count();
-if(e)
+for (TInt i = 0; i < entries; ++i)
 {
-for (TInt i = 0; i < iEntries; i++, e++)
+COpenFontSessionCacheEntry* e = iEntryArray[i];
+if (e != NULL)
 {
-if (ToCOpenFontSessionCacheEntryPointer(*e))
+COpenFont* font=const_cast<COpenFont*>(e->Font());
+if (font != NULL)
+font->DecrementCachedRefCount(iSessionHandle,NULL,ETrue);
+aHeap->Free(e->Bitmap());
+aHeap->Free(e);
+}
+}
+iEntryArray.Close(aHeap);
+}
+const COpenFontGlyph* COpenFontSessionCache::Glyph(const COpenFont* aFont, TInt aCode, TInt& aIndex)
+	{
+aIndex = -1;
+TInt oldest = KMaxTInt;
+TInt oldest_index = 0;
+TInt entries = iEntryArray.Count();
+TInt index = GLYPH_CODE(aCode) % entries;   // simple hash function to shorten searches
+for (TInt i = 0; i < entries; ++i, ++index)
+{
+if (index >= entries)
+index = 0;
+COpenFontSessionCacheEntry* e = iEntryArray[index];
+if (e == NULL)
+{
+if (aIndex == -1)
+aIndex = index;
+}
+else
+{
+if (e->Font() == aFont && e->iCode == aCode)
 {
-COpenFont* font=const_cast<COpenFont*>((ToCOpenFontSessionCacheEntryPointer(*e))->Font());
+e->iLastAccess = iLastAccess++;
-if (font)
+return e;
-font->DecrementCachedRefCount(iSessionHandle, NULL, ETrue);
+}
-aHeap->Free((ToCOpenFontSessionCacheEntryPointer(*e))->Bitmap());
+if (e->iLastAccess < oldest)
-aHeap->Free(ToCOpenFontSessionCacheEntryPointer(*e));
+{
+oldest = e->iLastAccess;
+oldest_index = index;
 }
 }
-aHeap->Free(Entry());
-iEntryOffset = 0;
 }
+if (aIndex == -1)
+aIndex = oldest_index;
+return NULL;
+	}
+void COpenFontSessionCache::Insert(RHeap* aHeap, COpenFontSessionCacheEntry* aEntry, TInt aIndex)
+	{
+if (aIndex < 0 || aIndex >= iEntryArray.Count())
+Panic(EFntSessionCacheIndexOutOfRange);
+COpenFontGlyph::Delete(aHeap, iEntryArray[aIndex]);
+iEntryArray.SetAt(aIndex, aEntry);
+aEntry->iLastAccess = iLastAccess++;
+	}
+COpenFontSessionCache::COpenFontSessionCache(TInt aSessionHandle):
+iSessionHandle(aSessionHandle),
+iLastAccess(0)
+{
 }
-#else
-void COpenFontSessionCache::Delete(RHeap* aHeap)
-	{
-	COpenFontSessionCacheEntry** e =iEntry;
-	for (TInt i = 0; i < iEntries; i++, e++)
-		{
-		if (*e)
-			{
-			COpenFont* font=const_cast<COpenFont*>((*e)->iFont);
-			if (font)
-				font->DecrementCachedRefCount(iSessionHandle, NULL, ETrue);
-			aHeap->Free((*e)->iBitmap);
-			aHeap->Free(*e);
-			}
-		}
-	aHeap->Free(iEntry);
-	}
-#endif //FNTSTORE_SUPPORT_FMM
-const COpenFontGlyph* COpenFontSessionCache::Glyph(const COpenFont* aFont, TInt aCode, TInt& aIndex)
-	{
-	aIndex = -1;
-	TInt oldest = KMaxTInt;
-	TInt oldest_index = 0;
-	TInt index = GLYPH_CODE(aCode) % iEntries;	// simple hash function to shorten searches
-	for (TInt i = 0; i < iEntries; i++, index++)
-		{
-		if (index >= iEntries)
-			index = 0;
-#ifdef FNTSTORE_SUPPORT_FMM
-		COpenFontSessionCacheEntry* e = ToCOpenFontSessionCacheEntryPointer(Entry()[index]);
-#else
-		COpenFontSessionCacheEntry* e = iEntry[index];
-#endif		//FNTSTORE_SUPPORT_FMM
-		if (!e)
-			{
-			if (aIndex == -1)
-				aIndex = index;
-			}
-		else
-			{
-#ifdef FNTSTORE_SUPPORT_FMM
-			if (e->Font() == aFont && e->iCode == aCode)
-#else
-			if (e->iFont == aFont && e->iCode == aCode)
-#endif //FNTSTORE_SUPPORT_FMM
-				{
-				e->iLastAccess = iLastAccess++;
-				return e;
-				}
-			if (e->iLastAccess < oldest)
-				{
-				oldest = e->iLastAccess;
-				oldest_index = index;
-				}
-			}
-		}
-	if (aIndex == -1)
-		aIndex = oldest_index;
-	return NULL;
-	}
-void COpenFontSessionCache::Insert(RHeap* aHeap, COpenFontSessionCacheEntry* aEntry, TInt aIndex)
-	{
-	if ((aIndex < 0) || (aIndex > iEntries))
-		Panic(EFntSessionCacheIndexOutOfRange);
-#ifdef 	FNTSTORE_SUPPORT_FMM
-	COpenFontSessionCacheEntry* e = ToCOpenFontSessionCacheEntryPointer(Entry()[aIndex]);
-	COpenFontGlyph::Delete(aHeap, e);
-	Entry()[aIndex] = reinterpret_cast<TInt>(aEntry) - reinterpret_cast<TInt>(this);
-#else
-	COpenFontGlyph::Delete(aHeap, iEntry[aIndex]);
-	iEntry[aIndex] = aEntry;
-#endif  //FNTSTORE_SUPPORT_FMM
-	aEntry->iLastAccess = iLastAccess++;
-	}
-COpenFontSessionCache::COpenFontSessionCache(TInt aSessionHandle, TInt aEntries)
-:	iSessionHandle(aSessionHandle),
-	iEntries(aEntries),
-	iLastAccess(0),
-#ifdef  FNTSTORE_SUPPORT_FMM
-iEntryOffset(0)
-#else
-iEntry(NULL)
-#endif  //FNTSTORE_SUPPORT_FMM
-	{
-	}
-#ifdef FNTSTORE_SUPPORT_FMM
-inline TInt* COpenFontSessionCache::Entry() const
-{
-if (iEntryOffset)
-{
-return reinterpret_cast<TInt*>(reinterpret_cast<TInt>(this) + iEntryOffset);
-}
-return NULL;
-}
-inline COpenFontSessionCacheEntry* COpenFontSessionCache::ToCOpenFontSessionCacheEntryPointer(TInt aOffset)const
-{
-if(aOffset)
-{
-return reinterpret_cast<COpenFontSessionCacheEntry*>(reinterpret_cast<TInt>(this) + aOffset);
-}
-return NULL;
-}
-#endif // FNTSTORE_SUPPORT_FMM
 /*COpenFontSessionCacheListItem*/
-#ifdef FNTSTORE_SUPPORT_FMM
 COpenFontSessionCacheListItem::COpenFontSessionCacheListItem(COpenFontSessionCache* aCache):
 	iNextOffset(NULL)
 	{
-	if(aCache)
+if(aCache != NULL)
-		{
+{
-		iCacheOffset = (TInt)aCache - (TInt)this;
+iCacheOffset = reinterpret_cast<TInt>(aCache) - reinterpret_cast<TInt>(this);
-		}
+}
-	else
+else
-		{
+{
-		iCacheOffset = NULL;
+iCacheOffset = NULL;
-		}
+}
 	}
 COpenFontSessionCacheListItem::~COpenFontSessionCacheListItem()
 	{
 	}
-#endif // FNTSTORE_SUPPORT_FMM
 /** Delete a COpenFontSessionCacheListItem from the passed heap.
 @param aHeap The heap to delete the COpenFontSessionCacheListItem from.
 */
 void COpenFontSessionCacheListItem::Delete(RHeap* aHeap)
 	{
-#ifdef FNTSTORE_SUPPORT_FMM
+COpenFontSessionCache* cache = Cache();
-	Cache()->Delete(aHeap);
+if (cache != NULL)
-	aHeap->Free(Cache());
+{
-	iCacheOffset=NULL;
+cache->Delete(aHeap);
-	iNextOffset=NULL;
+aHeap->Free(cache);
-#else
+}
-	iCache->Delete(aHeap);
+iCacheOffset=NULL;
-	aHeap->Free(iCache);
+iNextOffset=NULL;
-	iCache=NULL;
-#endif // FNTSTORE_SUPPORT_FMM
 	}
-#ifdef FNTSTORE_SUPPORT_FMM
 /** Get the next item to this cache list item.
 @return A pointer to the next item to this one in the session cache, or NULL
 if there is no next item.
 */
 COpenFontSessionCacheListItem* COpenFontSessionCacheListItem::Next()
 	{
 	if(iNextOffset)
 		{
-		COpenFontSessionCacheListItem* next = (COpenFontSessionCacheListItem*)((TInt)this + (TInt)iNextOffset);
+		COpenFontSessionCacheListItem* next = reinterpret_cast<COpenFontSessionCacheListItem*>(reinterpret_cast<TInt>(this) + iNextOffset);
 		return next;
 		}
 	else
 		{
 		return NULL;
 @param aNext Set this cache list item as the next item to this one in the session cache list.
 */
 void COpenFontSessionCacheListItem::SetNext(COpenFontSessionCacheListItem* aNext)
 	{
-	if(aNext)
+	if(aNext != NULL)
 		{
-		iNextOffset = (TInt)aNext - (TInt)this;
+		iNextOffset = reinterpret_cast<TInt>(aNext) - reinterpret_cast<TInt>(this);
 		}
 	else
 		{
 		iNextOffset = NULL;
 		}
 */
 COpenFontSessionCache* COpenFontSessionCacheListItem::Cache()
 	{
 	if(iCacheOffset)
 		{
-		COpenFontSessionCache* cache = (COpenFontSessionCache*)((TInt)this + (TInt)iCacheOffset);
+		COpenFontSessionCache* cache = reinterpret_cast<COpenFontSessionCache*>(reinterpret_cast<TInt>(this) + iCacheOffset);
 		return cache;
 		}
 	else
 		{
 		return NULL;
 */
 COpenFontSessionCacheListItem* COpenFontSessionCacheList::Start()
 	{
 	if(iStartOffset)
 		{
-		COpenFontSessionCacheListItem* start = (COpenFontSessionCacheListItem*)((TInt)this + (TInt)iStartOffset);
+		COpenFontSessionCacheListItem* start = reinterpret_cast<COpenFontSessionCacheListItem*>(reinterpret_cast<TInt>(this) + iStartOffset);
 		return start;
 		}
 	else
 		{
 		return NULL;
 @param aItem An item to be added to the session cache
 */
 void COpenFontSessionCacheList::SetStart(COpenFontSessionCacheListItem* aItem)
 	{
-	if(aItem!=NULL)
+	if(aItem != NULL)
 		{
-		iStartOffset = (TInt)aItem - (TInt)this;
+		iStartOffset = reinterpret_cast<TInt>(aItem) - reinterpret_cast<TInt>(this);
 		}
 	else
 		{
 		iStartOffset = 0;
 		}
 	}
-#endif // FNTSTORE_SUPPORT_FMM
 /** Delete all the items in the session cache if the current cache session handle
 matches the passed session handle.
 @param aHeap The heap base of the current process.
 	    if(KErrNone != sem.OpenGlobal(KSessionCacheSemaphoreName))
 	        {
 	        RDebug::Print(_L("COpenFontSessionCacheList::DeleteCache() can't open SessionCacheSemaphore"));
 	        return;
 	        }
-#ifdef FNTSTORE_SUPPORT_FMM
-	for (COpenFontSessionCacheListItem* curr = Start(); curr; prev = curr, curr = curr->Next())
+	    for (COpenFontSessionCacheListItem* curr = Start(); curr; prev = curr, curr = curr->Next())
-		{
+{
-		if (curr->Cache()->iSessionHandle == aSessionHandle)
+COpenFontSessionCache* cache = curr->Cache();
-			{
+if (cache != NULL && cache->iSessionHandle == aSessionHandle)
-			for(TInt i=0; i<KSessionCacheSemaphoreCount; i++)
+{
-			    {
+for (TInt i = 0; i < KSessionCacheSemaphoreCount; i++)
-				//coverity[lock]
+{
-				//coverity[double_lock]
+//coverity[lock]
-			    sem.Wait();
+//coverity[double_lock]
-			    }
+sem.Wait();
-			if (curr==Start())
+}
-				SetStart(curr->Next());
-			else
+if (curr == Start())
-				prev->SetNext(curr->Next());
+SetStart(curr->Next());
+else
-			curr->Delete(aHeap);
+prev->SetNext(curr->Next());
-			aHeap->Free(curr);
-			sem.Signal(KSessionCacheSemaphoreCount);
+curr->Delete(aHeap);
-			sem.Close();
+aHeap->Free(curr);
-			return;
-			}
-		}
-#else
-	for (COpenFontSessionCacheListItem* curr = iStart; curr; prev = curr, curr = curr->iNext)
-		{
-		if (curr->iCache->iSessionHandle == aSessionHandle)
-			{
-for(TInt i=0; i<KSessionCacheSemaphoreCount; i++)
-{
-sem.Wait();
-}
-			if (curr==iStart)
-				iStart   = curr->iNext;
-			else
-				prev->iNext = curr->iNext;
-			curr->Delete(aHeap);
-			aHeap->Free(curr);
 sem.Signal(KSessionCacheSemaphoreCount);
 sem.Close();
-			return;
+return;
-			}
+}
-		}
+}
-#endif // FNTSTORE_SUPPORT_FMM
+	    sem.Close();
 	}
 /** Delete all the items in the current session cache.
 @param aHeap The heap base of the current process.
 if(KErrNone != sem.OpenGlobal(KSessionCacheSemaphoreName))
 {
 RDebug::Print(_L("COpenFontSessionCacheList::Delete() can't open SessionCacheSemaphore"));
 return;
 }
-#ifdef FNTSTORE_SUPPORT_FMM
 	COpenFontSessionCacheListItem* cur = Start();
-#else
-	COpenFontSessionCacheListItem* cur = iStart;
-#endif // FNTSTORE_SUPPORT_FMM
 	COpenFontSessionCacheListItem* next = NULL;
 for(TInt i=0; i<KSessionCacheSemaphoreCount; i++)
 {
 	//coverity[lock]
 	//coverity[double_lock]
 sem.Wait();
 }
-	while (cur)
+	while (cur != NULL)
 		{
-#ifdef FNTSTORE_SUPPORT_FMM
 		next = cur->Next();
-#else
-		next = cur->iNext;
-#endif // FNTSTORE_SUPPORT_FMM
 		cur->Delete(aHeap);
 		aHeap->Free(cur);
 		cur = next;
 		}
 sem.Signal(KSessionCacheSemaphoreCount);
 if(KErrNone != sem.OpenGlobal(KSessionCacheSemaphoreName))
 {
 RDebug::Print(_L("COpenFontSessionCacheList::DeleteFontGlyphs can't global open SessionCacheSemaphore"));
 return;
 }
 sem.Wait();
-#ifdef FNTSTORE_SUPPORT_FMM
 	for (COpenFontSessionCacheListItem* p = Start(); p; p = p->Next())
-		{
+{
-		COpenFontSessionCache* cache=p->Cache();
+COpenFontSessionCache* cache = p->Cache();
-		TInt* e = cache->Entry();
+if (cache != NULL)
-		TInt entries = cache->iEntries;
+{
-		for (TInt i = 0; i < entries; i++, e++)
+TInt entries = cache->iEntryArray.Count();
-			{
+for (TInt i = 0; i < entries; ++i)
-			if ((cache->ToCOpenFontSessionCacheEntryPointer(*e))
+{
-			        && ((cache->ToCOpenFontSessionCacheEntryPointer(*e))->Font() == aFont))
+COpenFontSessionCacheEntry* e = cache->iEntryArray[i];
-				{
+if (e != NULL && e->Font() == aFont)
-				COpenFontSessionCacheEntry::Delete(aHeap, cache->ToCOpenFontSessionCacheEntryPointer(*e));
+{
-				*e = 0;
+COpenFontSessionCacheEntry::Delete(aHeap, e);
-				}
+cache->iEntryArray.SetAt(i, NULL);
-			}
+}
-		}
+}
-#else
+} //if(cache != NULL)
-	for (COpenFontSessionCacheListItem* p = iStart; p; p = p->iNext)
+}
-		{
-		COpenFontSessionCacheEntry** e = p->iCache->iEntry;
-		TInt entries = p->iCache->iEntries;
-		for (TInt i = 0; i < entries; i++, e++)
-			{
-			if ((*e) && ((*e)->iFont == aFont))
-				{
-				COpenFontSessionCacheEntry::Delete(aHeap, *e);
-				*e = NULL;
-				}
-			}
-		}
-#endif // FNTSTORE_SUPPORT_FMM
 	sem.Signal();
 	sem.Close();
 	}
 /**
 and the logic is handled in CFontStore::RemoveFile().
 */
 EXPORT_C COpenFontFile::~COpenFontFile()
 	{
 CFontStore *fs = GetFontStore();
-if (fs)
+if (fs != NULL)
 {
 fs->CleanupCacheOnOpenFontFileRemoval(this);
 }
 	delete iData;
 	}
 	(TOpenFontFaceAttrib&)a = aAttrib;
 	}
 void COpenFontFile::SetFontStoreL(CFontStore* aFontStore)
 	{
-	if (!iData)
+	if (iData == NULL)
 		{
 		iData = new (ELeave) TOpenFontFileData;
 		}
 	iData->iFontStore = aFontStore;
 	}
 	{
 	if (aBufferSize < 1)
 		aBufferSize = 1;
 	TInt bytes = sizeof(TOpenFontGlyphData) + aBufferSize - 1;
 	TOpenFontGlyphData* g = (TOpenFontGlyphData*)aHeap->Alloc(bytes);
-	if (g)
+	if (g != NULL)
 		{
 		Mem::FillZ(g, bytes);
 		g->iBitmapBufferSize = aBufferSize;
 		}
 	return g;

branch	RCL_3
changeset 1	e96e8a131979
parent 0	1fb32624e06b
child 2	6971d1c87c9a