/*

* 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 FNTREADR.CPP

*

*/

#include "FNTREADR.H"

const int KMarkFirstCharacterInTypeface = -1;

const int KBytesAddedForMetricIndex = 2;

const int KBytesForIndexForFillCharacters = 2;

const int KReportRateFrequencyInPercent = 10;

// class CroppedValues

class CroppedValues

	{

public:

	CroppedValues();

public:

	int iTopCrop;

	int iBottomCrop;

	int iLeftCrop;

	int iRightCrop;

	};

CroppedValues::CroppedValues()

 :	iTopCrop(0), iBottomCrop(0), iLeftCrop(0), iRightCrop(0)

	{}

// class FontReader

FontReader::FontReader()

 :	Reader(),

	iFontStore(),

	iFontStoreFile(NULL),

	iCharacterMetrics(NULL),

	iCodeSection(NULL),

	iFontBitmap(NULL),

	iTypeface(NULL),

	iReadFileFormat(ESymbianGDFFormat),

	iBitmapWidth(0),

	iBitmapHeight(0),

	iDefaultXMoveInPixels(KUndefinedInteger),

	iDefaultYMoveInPixels(KUndefinedInteger)

	{

	}

boolean FontReader::Read(const String& aFilename)

	{

	iFileName = aFilename;

	boolean state = Open(iFileName.Text());

	while (!_EOF() && state)

		{

		if (IdentComp(IdentBDFFileHeader) || IdentComp(IdentBDFComment))

			{

			state = ReadBDFFontBitmap();

			iReadFileFormat = EBDFFormat;

			}

		else if (IdentComp(IdentTypeface))

			state = ReadTypeface();

		else if (IdentComp(IdentFontStoreFile))

			state = ReadFontStoreFile();

		else

			{

			Error("Resource identifier expected");

			state = efalse;

			}

		if (state)

			state = NewLine();

		}

	return state;

	}

boolean FontReader::ReadMetricFromBDFCharacter(CharacterMetrics* aCharacterMetrics, CroppedValues* aCropped=  NULL)

	{

	int xMoveInPixels = 0;

	int yMoveInPixels = 0;

	int bitmapXOffset = 0;

	int bitmapYOffset = 0;

	boolean state = true;

	if (iDefaultXMoveInPixels != KUndefinedInteger)

		xMoveInPixels = iDefaultXMoveInPixels;

	if (iDefaultYMoveInPixels != KUndefinedInteger)

		yMoveInPixels = iDefaultYMoveInPixels;

	while (!IdentComp(IdentBDFEndChar) && !_EOF() && state)

		{

		iLexAnal->ReadNextLine(); // Skip to next line

		if (iLex->iType == ELexIdent)

			{

			if (IdentComp(IdentBDFCursorMove))

				{

				state = Number(xMoveInPixels);

				if (state)

					state = Number(yMoveInPixels);

				}

			else if (IdentComp(IdentBDFBitmapSizeAndDisplacement))

				{

				state = Number(iBitmapWidth);

				if (state)

					{

					state = Number(iBitmapHeight);

					state = Number(bitmapXOffset);

					state = Number(bitmapYOffset);

					}

				}

			else if (IdentComp(IdentBDFStartBitmap) && state)

				{

				int line = 0;

				for (line = 0; line < iBitmapHeight; line++)

					{

					iLexAnal->ReadNextLine();	// Skip to next line

					int bits = 0;

					int bitOffset = 0;

					int byteValue = 0;

					for (bits = 0; bits < iBitmapWidth; bits++)

						{

						if (bitOffset == 0)

							{

							Lexical lex;

							strncpy(lex.iText, &iLexAnal->iLine[bits >> 2], 2);

							lex.iText[2] = '\0';

							byteValue = lex.CovertStringToHex();

							bitOffset = 8;

							}

						bitOffset--;

						int bitValue = (byteValue >> bitOffset) & 1;

						iBitArray[bits][line] = bitValue;

						}

					}

				}

			}

		else

			{

			Error("Fontbitmap identifier expected");

			state = efalse;

			}

		}

	if (state)

		state = NewLine();

//

// Make sure that bitmap is fully cropped

//

	int leftCrop = 0;

	int rightCrop = 0;

	int topCrop = 0;

	int bottomCrop = 0;

	int line = 0;

	while (BitmapLineEmpty(line) && line < iBitmapHeight)

		{

		topCrop++;;

		line++;

		}

	line = iBitmapHeight - 1;

	while (BitmapLineEmpty(line) && line > topCrop)

		{

		bottomCrop++;

		line--;

		}

	int column = iBitmapWidth - 1;

	while (BitmapColumnEmpty(column) && column >= 0)

		{

		rightCrop++;

		column--;

		}

	column = 0;

	while (BitmapColumnEmpty(column) && column < iBitmapWidth - 1 - rightCrop)

		{

		leftCrop++;

		column++;

		}

	int croppedBitmapHeight = iBitmapHeight - topCrop - bottomCrop;

	int croppedBitmapWidth = iBitmapWidth - leftCrop - rightCrop;

	int croppedLeftAdjust = bitmapXOffset + leftCrop;

	int croppedRightAdjust = (xMoveInPixels - croppedLeftAdjust - croppedBitmapWidth);

	int croppedAscent = croppedBitmapHeight + bitmapYOffset + bottomCrop;

	if(state)

		{

		aCharacterMetrics->iAscentInPixels = (chardim) croppedAscent;

		aCharacterMetrics->iHeightInPixels = (chardim) croppedBitmapHeight;

		aCharacterMetrics->iLeftAdjustInPixels = (chardim) croppedLeftAdjust;

		aCharacterMetrics->iMoveInPixels = (chardim) xMoveInPixels;

		aCharacterMetrics->iRightAdjustInPixels = (chardim) croppedRightAdjust;

		if (aCropped)

			{

			aCropped->iBottomCrop = bottomCrop;

			aCropped->iLeftCrop = leftCrop;

			aCropped->iRightCrop = rightCrop;

			aCropped->iTopCrop = topCrop;

			}

		}

	return state;

	}

boolean FontReader::ReadBDFCharacter(int /*aCode*/)

	{

	boolean state = etrue;

	ObjectList<String*> character;

	iCharacterMetrics = new CharacterMetrics;

	CroppedValues* croppedValues = new CroppedValues;

	state = ReadMetricFromBDFCharacter(iCharacterMetrics, croppedValues);

	if (state)

		{

		BitmapOffset* offset = new BitmapOffset((uint16)iCodeSection->iCharactersBitmap.iByteList.Length());

		iCodeSection->iCharactersBitmap.iByteList.NewByte();

		iCodeSection->iCharacters.iBitmapOffsetList.Add(offset);

		int index = iFontBitmap->iCharacterMetrics->Index(*iCharacterMetrics);

		if (index == -1)

			{

			Error("Internal Compiler Error");

			state = 0;

			}

		delete iCharacterMetrics;

		if (state)

			{

			iCodeSection->iCharactersBitmap.AddIndex(index);

			int line = croppedValues->iTopCrop;

			boolean repeatLines;

			int countLines = 0;

			const int bottomCrop = croppedValues->iBottomCrop;

			while (line < (iBitmapHeight - bottomCrop))

				{

				if ((line + 1) == (iBitmapHeight - bottomCrop))

					{

					repeatLines = efalse;

					countLines = 1;

					}

				else if (!CompareBitmapLines(line, line + 1))

					{

					repeatLines = efalse;

					for (countLines = 2; ((line + countLines) < (iBitmapHeight - bottomCrop)) && (countLines < KMaxNumberRepeatedLines); countLines++)

						{

						if (CompareBitmapLines(line + countLines - 1, line + countLines))

							break;

						}

					}

				else

					{

					repeatLines = etrue;

					for (countLines = 2; ((line + countLines) < (iBitmapHeight - bottomCrop)) && (countLines < KMaxNumberRepeatedLines); countLines++)

						{

						if (!CompareBitmapLines(line, line + countLines))

							break;

						}

					}

				char bit;

				if (repeatLines)

					bit = 0;

				else

					bit = 1;

				iCodeSection->iCharactersBitmap.iByteList.AddBit(bit);

				for (int digit = 0; digit < 4; digit++)

					{

					bit = char(countLines >> digit);

					iCodeSection->iCharactersBitmap.iByteList.AddBit(bit);

					}

				int lineFromTop;

				for (lineFromTop = line; lineFromTop < (line + countLines); lineFromTop++)

					{

					if ((!repeatLines) || (lineFromTop == line))

						{

						int column;

						for (column = croppedValues->iLeftCrop;

							column < iBitmapWidth - croppedValues->iRightCrop; column++)

							{

							if (iBitArray[column][lineFromTop] == 1)

								bit = 1;

							else

								bit = 0;

							iCodeSection->iCharactersBitmap.iByteList.AddBit(bit);

							}

						}

					}

				line = line+countLines;

				}

			}

		}

	delete croppedValues;

	return state;

	}

boolean FontReader::ReadBDFChars(const int aNumberOfGlyphsInFile, const int aMaxConsecutiveFillChars)

	{

	boolean state = etrue;

	boolean newCodeSection = etrue;

	int currentEncodingValue = 0; // each glyph has an unique encoding value

	int lastEncodingValue = KMarkFirstCharacterInTypeface;

	const int maxCharacterBitmapsize =

		((KMaxBitmapWidth * KMaxBitmapHeight) / KNumberOfBitsInByte) + KBytesAddedForMetricIndex + KBytesForIndexForFillCharacters;

	iCodeSection = NULL;

	for (int numberGlyphsRead = 0; state && numberGlyphsRead < aNumberOfGlyphsInFile && !_EOF(); numberGlyphsRead++)

		{

		if (state && iCodeSection && iCodeSection->iCharactersBitmap.iByteList.Length() + maxCharacterBitmapsize >= KMaxSizeCodeSectionBitmap)

			{

			newCodeSection = etrue;

			}

		state = IdentComp(IdentBDFCharLabel);

		if (!state)

			ErrorIdentifierExpected(IdentBDFCharLabel);

		if (state)

			iLexAnal->ReadNextLine(); // Skip to next line

 		if (IdentComp(IdentBDFChar))

			{

			state = Number(currentEncodingValue);

			}

		else

			{

			state = efalse;

			ErrorIdentifierExpected(IdentBDFChar);

			}

		if (KLowestPermittedCharacterEncoding > currentEncodingValue ||

			KHighestPermittedCharacterEncoding < currentEncodingValue)

			{

			while (!IdentComp(IdentBDFEndChar) && !_EOF() && state) 

				// Skip fill character.

				{

				iLexAnal->ReadNextLine(); // Skip to next line

				}

			iLexAnal->ReadNextLine();

			continue;

			}

		if (!iCodeSection || state && (currentEncodingValue > (lastEncodingValue + 1 + aMaxConsecutiveFillChars)))

			{

			// First character skip to new code section

			newCodeSection = etrue;

			}

		else if (state && !newCodeSection && (currentEncodingValue > lastEncodingValue + 1))

			{

			WriteFillCharacters(currentEncodingValue - (lastEncodingValue + 1));

			}

		else if (state && currentEncodingValue <= lastEncodingValue)

			{

			Error("CodeSection out of sequence");

			state = efalse;

			}

		if (state && newCodeSection)

			{

			if (iCodeSection)

				{

				iCodeSection->iEnd = (uint16) lastEncodingValue;

				iFontBitmap->iCodeSectionList.Add(iCodeSection);

				PrintoutCodeSection(iCodeSection);

				}

			iCodeSection = new BitmapCodeSection;

			iCodeSection->iStart = (uint16) currentEncodingValue;

			}

		if (state)

			state = ReadBDFCharacter(currentEncodingValue);

		newCodeSection = efalse;

		lastEncodingValue = currentEncodingValue;

		}

	if (state)

		{

		iCodeSection->iEnd = (uint16) lastEncodingValue;

		iFontBitmap->iCodeSectionList.Add(iCodeSection);

		PrintoutCodeSection(iCodeSection);

		}

	return state;

	}

void FontReader::PrintoutCodeSection(const BitmapCodeSection* aCodeSection) const

	{

	cout << hex << "Codesection 0x" << aCodeSection->iStart << ": 0x" << aCodeSection->iEnd << " read" << endl;

	cout.flush();

	}

boolean FontReader::ReadBDFFontBitmap()

	{

	boolean state = etrue;

	String label;

	iFontBitmap = new FontBitmap;

	int pointSize;

	int xresolution; // in dots per inch

	int yresolution; // in dots per inch

	int widthBoundingBox = 0; // In pixels

	int heightBoundingBox = 0; // in pixels

	int boundingBoxXOffset = 0; // From origin (cursor position at baseline)

	int boundingBoxYOffset = 0;	// From origin (cursor position at baseline)

	int numberChars = 0;

	String fontLabel;

	int maxNormalCharWidth = KUndefinedInteger;

	uid fontUid = KNullUid;

	int posture = PostureUpright;

	int strokeWeight = StrokeWeightNormal;

	int defaultXMoveInPixels = KUndefinedInteger;

	int defaultYMoveInPixels = KUndefinedInteger;

	int writingDirection = 0;

	int maxConsecutiveFillChars = 0;	// Max permitted "fill" characters with zero size to prevent

										// break between code sections.

	int fontAscent = 0;

	int fontDescent = 0;

	while (!IdentComp(IdentBDFNumChars) && !_EOF() && state)

		{

		iLexAnal->ReadNextLine(); // Skip to next line

		if (iLex->iType == ELexIdent)

			{

			if (IdentComp(IdentBDFFontBitmap))

				{

				state = IdentCopy(fontLabel);

				}

			if (IdentComp(IdentBDFPointSize))

				{

				state = Number(pointSize);

				if (state)

					state = Number(xresolution);

				if (state)

					state = Number(yresolution);

				}

			else if (IdentComp(IdentBDFFontDesignBox))

				{

				state = Number(widthBoundingBox);

				if (state)

					state = Number(heightBoundingBox);

				if (state)

					state = Number(boundingBoxXOffset);

				if (state)

					state = Number(boundingBoxYOffset);

				}

			else if (IdentComp(IdentBDFWritingDirection))

				{

				Number(writingDirection);

				if (writingDirection != 0)

					cout << "Warning: Only left to right writing direction supported by EPOC32";

				}

			else if (IdentComp(IdentBDFCursorMove))

				{

				state = Number(defaultXMoveInPixels);

				if (state)

					state = Number(defaultYMoveInPixels);

				}

			else if (IdentComp(IdentBDFStartProperties))	// Adding additional properties

				{

				int numberOfProperties;

				state = Number(numberOfProperties);

				if (state)

					state = NewLine();

				{for (int properties = 0; properties < numberOfProperties && !_EOF() && state; properties++)

					{

					if (IdentComp(IdentBDFPropertyUid) || IdentComp(IdentUid))

						state = Number(fontUid);

					else if (IdentComp(IdentBDFPropertyBold) || IdentComp(IdentBold))

						state = Number(strokeWeight);

					else if (IdentComp(IdentBDFPropertyItalic) || IdentComp(IdentItalic))

						state = Number(posture);

					else if (IdentComp(IdentBDFPropertyFontAscent))

						state = Number(fontAscent);

					else if (IdentComp(IdentBDFPropertyFontDescent))

						state = Number(fontDescent);

					else if	(IdentComp(IdentBDFPropertyMaxNormalCharWidth) || IdentComp(IdentMaxNormalCharWidth))

						state = Number(maxNormalCharWidth);

					else if (IdentComp(IdentBDFPropertyMaxConsecutiveFillChars) || IdentComp(IdentMaxConsecutiveFillChars))

						state = Number(maxConsecutiveFillChars);

					iLexAnal->ReadNextLine();	// Skip to next line

					}

				}

				if (state)

					{

					state = IdentComp(IdentBDFEndProperties);

					if (!state)

						ErrorIdentifierExpected(IdentBDFEndProperties);

					}

				}

			}

		else

			{

			Error("Identifier expected");

			state = efalse;

			}

		}

//

// Check that maximum size of bitmap glyph not exceeded.

//

	if (widthBoundingBox>KMaxBitmapWidth || widthBoundingBox>KMaxBitmapWidth)

		{

		state = efalse;

		cout << "Error: A font bounding box dimension exceeds maximum permitted in EPOC32";

		}

// Check that have everthing that we need and set some bitmap properties.

	iFontBitmap->iMaxCharWidthInPixels = (chardim) widthBoundingBox;

	if (fontAscent + fontDescent)

		{

		iFontBitmap->iCellHeightInPixels =( chardim) (fontAscent+fontDescent);

		iFontBitmap->iAscentInPixels = (chardim) (fontAscent);

		}