/*

* Copyright (c) 1997-2009 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: 

* Header FNTRECRD.CPP

*

*/

#include "FNTRECRD.H"

const int KNumberOfPopularIndices = 128;

const int KNumberOfBitsInByte = 8;

const int KNumberOfBitsInTwoBytes = 16;

BitmapOffset::BitmapOffset(uint16 aBitmapOffset)

 :	iBitmapOffset(aBitmapOffset)

	{}

void BitmapOffset::Externalize(ostream& out)

	{

	out.write((char*) &iBitmapOffset,sizeof(iBitmapOffset));

	}

CharacterMetrics::CharacterMetrics()

 :	iAscentInPixels(0),

	iHeightInPixels(0),

	iLeftAdjustInPixels(0),

	iMoveInPixels(0),

	iRightAdjustInPixels(0)

	{

	}

void CharacterMetrics::Externalize(ostream& out)

	{

	out.write((char*) &iAscentInPixels, sizeof(iAscentInPixels));

	out.write((char*) &iHeightInPixels, sizeof(iHeightInPixels));

	out.write((char*) &iLeftAdjustInPixels, sizeof(iLeftAdjustInPixels));

	out.write((char*) &iMoveInPixels, sizeof(iMoveInPixels));

	out.write((char*) &iRightAdjustInPixels, sizeof(iRightAdjustInPixels));

	}

MetricDistributionMember::~MetricDistributionMember()

	{

	delete iMetric;

	}

MetricDistributionMember::MetricDistributionMember()

 :	iFrequency(0), iMetric(0)

	{}

CharacterMetrics* MetricDistributionMember::Metric() const

	{

	return iMetric;

	}

int MetricDistributionMember::Frequency() const

	{

	return iFrequency;

	}

void MetricDistributionMember::SetFrequency(int aFrequency)

	{

	iFrequency = aFrequency;

	}

void MetricDistributionMember::IncrementFrequency(int aIncrementBy)

	{

	iFrequency += aIncrementBy;

	}

void MetricDistributionMember::SetMetric(CharacterMetrics* aMetric)

	{

	iMetric = aMetric;

	}

void MetricDistributionMember::Externalize(ostream& out)

	{

	iMetric->Externalize(out);

	}

MetricDistribution::~MetricDistribution()

	{

	iCharacterMetricsList.Destroy();

	}

MetricDistribution* MetricDistribution::New()

	{

	return new MetricDistribution;

	}

MetricDistribution::MetricDistribution()

	{}

void MetricDistribution::SortMetricsByFrequency()

	{	// Only need sort the most popular 128, since after this 2 bytes will always be used

	int maxIndex = iCharacterMetricsList.Size();

	if (maxIndex > KNumberOfPopularIndices)

		{

		maxIndex = KNumberOfPopularIndices;

		}

	for(int indexToSet = 0; indexToSet < maxIndex; indexToSet++)

		{

		const CharacterMetrics& mostPopularRemaining = MostPopular(indexToSet);

		SetIndex(mostPopularRemaining, indexToSet);

		}

	}

void MetricDistribution::SetIndex(const CharacterMetrics& aMetrics, int aIndexToSet)

	{

	int currentPos = Index(aMetrics);

	if (currentPos != aIndexToSet)

		{

		MetricDistributionMember* match = iCharacterMetricsList[currentPos];

		MetricDistributionMember* swapPos = iCharacterMetricsList[aIndexToSet];

		CharacterMetrics* tempMet = match->Metric();

		const int tempFreq = match->Frequency();

		match->SetMetric(swapPos->Metric());

		match->SetFrequency(swapPos->Frequency());

		swapPos->SetMetric(tempMet);

		swapPos->SetFrequency(tempFreq);

		}

	}

void MetricDistribution::AddOrIncrementMetric(const CharacterMetrics& aMetrics, int aFrequency)

	{

	boolean match = false;

	const CharacterMetrics* trial = NULL;

	MetricDistributionMember* link = NULL;

	int index;

	int maxIndex = iCharacterMetricsList.Size();

	for(index = 0; index < maxIndex && !match; index++)

		{

		link = iCharacterMetricsList[index];

		if (link)

			trial = link->Metric();

		if (trial && (trial->iAscentInPixels == aMetrics.iAscentInPixels)

			&& (trial->iHeightInPixels == aMetrics.iHeightInPixels)

			&& (trial->iLeftAdjustInPixels == aMetrics.iLeftAdjustInPixels)

			&& (trial->iMoveInPixels == aMetrics.iMoveInPixels)

			&& (trial->iRightAdjustInPixels == aMetrics.iRightAdjustInPixels))

			{

			match = true;

			}

		}

	if (match)

		{

		link->IncrementFrequency(aFrequency);

		}

	else

		{

		MetricDistributionMember* newLink = new MetricDistributionMember;

		newLink->IncrementFrequency(aFrequency);

		CharacterMetrics* newMetric = new CharacterMetrics(aMetrics);

		newLink->SetMetric(newMetric);

		iCharacterMetricsList.Add(newLink);

		}

	}

const CharacterMetrics& MetricDistribution::MostPopular(int aStartIndex)

	{

	// finds the most popular metric above index aStartIndex. Allows for a fairly quick sort of the metircs to be done.

	MetricDistributionMember* link = NULL;

	const CharacterMetrics* mostPopular = NULL;

	int frequencyOfMostPopular = 0;

	int frequency = 0;

	int count;

	int total = 0; // for debugging

	const int size = iCharacterMetricsList.Size();

	for (count = aStartIndex; count < size; count++)

		{

		link = iCharacterMetricsList[count];

		frequency = link->Frequency();

		if (frequency>frequencyOfMostPopular)

			{

			mostPopular = link->Metric();

			frequencyOfMostPopular = frequency;

			}

		total += frequency;

		}

	return *mostPopular;

	}

int MetricDistribution::Index(const CharacterMetrics& aMetrics)

	{

	boolean same = false;

	CharacterMetrics* match = NULL;

	int i;

	int size = iCharacterMetricsList.Size();

	// see if we have this one already

	for (i = 0; i < size; i++)

		{

		if (iCharacterMetricsList[i])

			{

			match = iCharacterMetricsList[i]->Metric();

			}

		if ((match->iAscentInPixels == aMetrics.iAscentInPixels)

			&& (match->iHeightInPixels == aMetrics.iHeightInPixels)

			&& (match->iLeftAdjustInPixels == aMetrics.iLeftAdjustInPixels)

			&& (match->iMoveInPixels == aMetrics.iMoveInPixels)

			&& (match->iRightAdjustInPixels == aMetrics.iRightAdjustInPixels))

			{

			same = true;

			break;

			}

		}

	if (!same)

		{

		i = -1;	// not found

		}

	return i;

	}

void MetricDistribution::Externalize(ostream& out)

	{

	streamoff idOffset = iStreamId;

	out.write(reinterpret_cast<char*>(&idOffset), sizeof(idOffset));

	int32 numMetrics = iCharacterMetricsList.Size();

	out.write(reinterpret_cast<char*>(&numMetrics), sizeof(numMetrics));

	}

void MetricDistribution::ExternalizeComponents(ostream& out)

	{

	iStreamId = out.tellp();

	iCharacterMetricsList.Externalize(out);

	}

void Characters::Externalize(ostream& out)

	{

	iStreamId = out.tellp();

	iBitmapOffsetList.Externalize(out);

	}

Characters::~Characters()

	{

	iBitmapOffsetList.Destroy();

	}

ByteList::ByteList()

 :	iString(), iOffset(0)

	{

	}

void ByteList::AddBit(char aBit)

	{

	if (iOffset > 7)

		NewByte();

	const char mask = 1;

	aBit = char(aBit & mask);

	char byte = char(aBit << iOffset);

	int index = iString.Length() - 1;

	iString[index] = char(iString[index] | byte);

	iOffset++;

	}

void ByteList::NewByte()

	{

	char byte = 0;

	iString += byte;

	iOffset = 0;

	}

int ByteList::Length() const

	{

	return iString.Length();

	}

void ByteList::Externalize(ostream& out)

	{

	int32 length = iString.Length();

	out.write((char*) &length, sizeof(length));

	out.write(iString.Text(), length);

	}

void CharactersBitmap::Externalize(ostream& out)

	{

	iStreamId = out.tellp();

	iByteList.Externalize(out);

	}

void CharactersBitmap::AddIndex(int aIndex)

	{// Add index to metrics into the bitmap code section

	 // Use 1 byte for most popular indices, 2 bytes otherwise

	int power;

	if (aIndex < KNumberOfPopularIndices)

		{

		iByteList.AddBit(0);

		power = KNumberOfBitsInByte - 1;

		}

	else

		{

		iByteList.AddBit(1);

		power = KNumberOfBitsInTwoBytes - 1;

		}

	char sigBit = 0;

	// Add significant bits of index.

	for(int bitToAdd = 0; bitToAdd < power; bitToAdd++)

		{

		sigBit = char(aIndex >> bitToAdd);

		iByteList.AddBit(sigBit);

		}

	}

void BitmapCodeSection::Externalize(ostream& out)

	{

	out.write((char*) &iStart, sizeof(iStart));

	out.write((char*) &iEnd, sizeof(iEnd));

	streamoff idOffset = iCharacters.iStreamId;

	out.write(reinterpret_cast<char*>(&idOffset), sizeof(idOffset));

	idOffset = iCharactersBitmap.iStreamId;

	out.write(reinterpret_cast<char*>(&idOffset), sizeof(idOffset));

	}

void BitmapCodeSection::ExternalizeComponents(ostream& out)

	{

	iCharacters.Externalize(out);

	iCharactersBitmap.Externalize(out);

	}

FontBitmap::FontBitmap()

 :	iPosture(PostureUpright),

	iStrokeWeight(StrokeWeightNormal),

	iIsProportional(efalse),

	iCellHeightInPixels(0),

	iAscentInPixels(0),

	iMaxCharWidthInPixels(0),

	iMaxNormalCharWidthInPixels(0),

	iBitmapEncoding(0)

	{

	iCharacterMetrics = MetricDistribution::New();

	}

void FontBitmap::Externalize(ostream& out)

	{

	iStreamId = out.tellp();

	out.write((char*) &iUid, sizeof(iUid));

	out.put((char) iPosture);

	out.put((char) iStrokeWeight);

	out.put((char) iIsProportional);

	out.write((char*) &iCellHeightInPixels, sizeof(iCellHeightInPixels));

	out.write((char*) &iAscentInPixels, sizeof(iAscentInPixels));

	out.write((char*) &iMaxCharWidthInPixels, sizeof(iMaxCharWidthInPixels));

	out.write((char*) &iMaxNormalCharWidthInPixels, sizeof(iMaxNormalCharWidthInPixels));

	out.write((char*) &iBitmapEncoding, sizeof(iBitmapEncoding));

	iCharacterMetrics->Externalize(out);

	iCodeSectionList.Externalize(out);

	}

void FontBitmap::ExternalizeComponents(ostream& out)

	{

	// write out characters and chactersbitmap records

	iCharacterMetrics->ExternalizeComponents(out);

	int size = iCodeSectionList.Size();

	for (int i = 0; i < size; i++)

		{

		iCodeSectionList[i]->ExternalizeComponents(out);

		}

	}

FontBitmap::~FontBitmap()

	{

	iCodeSectionList.Destroy();

	delete iCharacterMetrics;

	}

TypefaceFontBitmap::TypefaceFontBitmap(FontBitmap* aFontBitmap)

 :	iFontBitmap(aFontBitmap),

	iFontBitmapUid(KNullUid),

	iWidthFactor(1),

	iHeightFactor(1)

	{

	}

TypefaceFontBitmap::TypefaceFontBitmap(uid aFontBitmapUid)

 :	iFontBitmap(NULL),

	iFontBitmapUid(aFontBitmapUid),

	iWidthFactor(1),

	iHeightFactor(1)

	{

	}

void TypefaceFontBitmap::Externalize(ostream& out)

	{

	if (iFontBitmap)

		out.write((char*) &iFontBitmap->iUid, sizeof(iFontBitmap->iUid));

	else

		out.write((char*) &iFontBitmapUid, sizeof(iFontBitmapUid));

	out.write((char*) &iWidthFactor, sizeof(iWidthFactor));

	out.write((char*) &iHeightFactor, sizeof(iHeightFactor));

	}

void FntTypeface::Externalize(ostream& out)

	{

	iStreamId = out.tellp();

	Typeface::Externalize(out);

	iTypefaceFontBitmapList.Externalize(out);

	}

FontStoreFile::FontStoreFile()

 :	iCollectionUid(KNullUid),

	iKPixelAspectRatio(1000),

	iCopyrightInfo(),

	iDataStreamId(0)

	{

	}

void FontStoreFile::AddTypeface(FntTypeface *aTypeface)

	{

	iTypefaceList.Add(aTypeface);

	for (int i = 0; i < aTypeface->iTypefaceFontBitmapList.Size(); i++)

		{

		if (aTypeface->iTypefaceFontBitmapList[i]->iFontBitmap)

			iFontBitmapList.Add(aTypeface->iTypefaceFontBitmapList[i]->iFontBitmap);

		}

	}

void FontStoreFile::AddFontBitmap(FontBitmap* aFontBitmap)

	{

	iFontBitmapList.Add(aFontBitmap);

	}

void FontStoreFile::Externalize(ostream& out)

	{

	ExternalizeHeader(out);

	ExternalizeComponents(out);

	}

void FontStoreFile::ExternalizeHeader(ostream& out)

	{

	out.write((char*) &KStoreWriteOnceLayoutUid, sizeof(KStoreWriteOnceLayoutUid));

	out.write((char*) &KFontStoreFileUid, sizeof(KFontStoreFileUid));

	out.write((char*) &KNullUid, sizeof(KNullUid));

	out.write((char*) &KFontStoreFileChecksum, sizeof(KFontStoreFileChecksum));

	streamoff idOffset = iStreamId;

	out.write(reinterpret_cast<char*>(&idOffset), sizeof(idOffset));

	iStreamId = out.tellp();

	out.write((char*) &KFnttranVersion, sizeof(KFnttranVersion));

	out.write((char*) &iCollectionUid, sizeof(iCollectionUid));

	out.write((char*) &iKPixelAspectRatio, sizeof(iKPixelAspectRatio));

	idOffset = iDataStreamId;

	out.write(reinterpret_cast<char*>(&idOffset), sizeof(idOffset));

	iCopyrightInfo.Externalize(out);

	}

void FontStoreFile::ExternalizeComponents(ostream& out)

	{

	iDataStreamId = out.tellp();

	iFontBitmapList.Externalize(out);

	iTypefaceList.Externalize(out);

	iFontBitmapList.ExternalizeComponents(out);

	}

boolean FontStore::Store(const String& aFilename)

	{

	boolean state = efalse;

	ofstream fout;

	String string = aFilename;

	fout.open(string.Text(), ios::binary);

	if (!fout.fail())

		{

		iFontStoreFile->Externalize(fout);

		fout.close();

		fout.open(string.Text(), ios::binary | ios::trunc);

		iFontStoreFile->Externalize(fout);

		fout.close();

		state = etrue;

		}

	return state;

	}

void FontStore::AddFontStoreFile(FontStoreFile* aFontStoreFile)

	{

	iFontStoreFile = aFontStoreFile;

	}

void FontStore::AddFontBitmap(FontBitmap *aFontBitmap)

	{

	iFontBitmapList.Add(aFontBitmap);

	}

Record* FontStore::FindFontBitmap(String& aLabel)

	{

	return iFontBitmapList.LabelToRecord(aLabel);

	}

void FontStore::AddTypeface(FntTypeface *aTypeface)

	{

	iTypefaceList.Add(aTypeface);

	}

Record* FontStore::FindTypeface(String& aLabel)

	{

	return iTypefaceList.LabelToRecord(aLabel);

	}

FontStore::FontStore()

 :	iFontStoreFile(NULL),

	iFontBitmapList(),

	iTypefaceList()

	{

	}

FontStore::~FontStore()

	{

	delete iFontStoreFile;

	iFontBitmapList.Destroy();

	iTypefaceList.Destroy();

	}