/*

 * Copyright (c) 2003-2010 Nokia Corporation and/or its subsidiary(-ies).

 * All rights reserved.

 * This component and the accompanying materials are made available

 * under the terms of "Eclipse Public License v1.0"

 * which accompanies this distribution, and is available

 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

 *

 * Initial Contributors:

 * Nokia Corporation - initial contribution.

 *

 * Contributors:

 *

 * Description: 

 * Chris Cooper, 09 March 1999

 * This application loads a scaleable open font and extracts a particular

 * user-specified size from it which it then outputs as a BDF format font

 * file. This can then be turned into an EPOC bitmap font using other tools.

 * At the moment the required font name and PPEM size are specified in a

 * program statement, so this utility must be recompiled. It is intended to

 * change this to obtain the input from a text file - and to allow multiple

 * conversions to be specified at once.

 * This application has to be a Unicode build to function.

 * If this #define is enabled than, instead of getting a useable BDF file,

 * the hex char definitions are replaced by visible bitmaps of the chars.

 * It should, therefore, be commented out in normal use.

 *

 */

 //#define SHOW_FONT_PICTURES_INSTEAD_OF_HEX

 #include <e32std.h>

 #include <e32test.h>

 #include <bitstd.h>

 #include <bitdev.h>

 #include <fbs.h>

 #include <f32file.h>

 #include "bdfharn.h"

 TPtrC CBDFHarness::iFacename(_L("DejaVu Sans Condensed"));

 TInt  CBDFHarness::iPixelSize = 8;

 TPtrC CBDFHarness::iFilename(_L("Swi8br"));

 TPtrC CBDFHarness::iUid(_L("268457817"));

 TFontPosture CBDFHarness::iPosture = EPostureUpright;

 //TFontPosture CBDFHarness::iPosture = EPostureItalic;

 //TFontStrokeWeight CBDFHarness::iStrokeWeight = EStrokeWeightNormal;

 TFontStrokeWeight CBDFHarness::iStrokeWeight = EStrokeWeightBold;

 TFontPrintPosition CBDFHarness::iPrintPosition = EPrintPosNormal;

 //TFontPrintPosition CBDFHarness::iPrintPosition = EPrintPosSuperscript;

 //TFontPrintPosition CBDFHarness::iPrintPosition = EPrintPosSubscript;

 TBuf<256> buffer;

 // this function is a hack to take a Unicode string containing

 // only chars <= 255 and put out the 8 bit version to the file

 void FileWrite8(RFile& aFile, const TDesC& aText)

 	{

 	// It's Unicode so we've got to step down from 16 bit desc to 8 bit file

 	TInt length = aText.Length();

 	HBufC8* buffer8 = HBufC8::NewMaxL(length);

 	TPtr8 p = buffer8->Des();

 	TUint16 c;

 	TUint8 b;

 	int k = 0;

 	for (int r = 0; r < length; r++)

 		{

 		c = aText[r];

 		b = (TUint8)c;

 		p[k++] = b;

 		}

 	aFile.Write(*buffer8);

 	delete buffer8;

 	}

 CBDFHarness::CBDFHarness(const TDesC &aTitle, const TDesC &aHeading): iTest(aTitle)

 	{

 	iTest.Title();

 	iTest.Start(aHeading);

 	}

 CBDFHarness* CBDFHarness::NewL(const TDesC &aTitle, const TDesC &aHeading)

 	{

 	CBDFHarness* t = new (ELeave)CBDFHarness(aTitle, aHeading);

 	CleanupStack::PushL(t);

 	t->ConstructL();

 	CleanupStack::Pop();

 	return t;

 	}

 void CBDFHarness::ConstructL()

 	{

 	User::LeaveIfError(RFbsSession::Connect());

 	iFbs = RFbsSession::GetSession();

 	if (iFbs == NULL)

 		User::Leave(KErrGeneral);

 	iDev = CFbsScreenDevice::NewL(_L("scdv"),EGray4);

 	iDev->ChangeScreenDevice(NULL);

 	iDev->SetAutoUpdate(ETrue);

 	iDev->CreateContext(iGc);

 	TFontSpec fs(iFacename, iPixelSize);

 	fs.iFontStyle.SetPosture(iPosture);

 	fs.iFontStyle.SetStrokeWeight(iStrokeWeight);

 	fs.iFontStyle.SetPrintPosition(iPrintPosition);

 	TInt error = iDev->GetNearestFontInPixels((CFont*&)iStandardFont,fs);

 	if (error)

 		User::Panic(_L("Could not create this font"),error);

 	}

 CBDFHarness::~CBDFHarness()

 	{

 	if (iStandardFont)

 		iDev->ReleaseFont(iStandardFont);

 	delete iGc;

 	delete iDev;

 	RFbsSession::Disconnect();

 	iTest.Close();

 	}

 void CBDFHarness::MakeBDFFontL()

 	{

 	TOpenFontFaceAttrib attrib;

 	iStandardFont->GetFaceAttrib(attrib);

 	TPtrC familyName = attrib.FamilyName();

 	TPtrC fullName = attrib.LocalFullName();

 	TOpenFontMetrics fMetrics;

 	iStandardFont->GetFontMetrics(fMetrics);

 	iPPEM = fMetrics.Size();

 	// Open file session

 	RFs file_session;

 	User::LeaveIfError(file_session.Connect());

 	file_session.MkDir(_L("\\BDFfonts\\"));

 	// Open file

 	RFile file;

 	buffer.Format(_L("\\BDFfonts\\%S %d.bdf"), &fullName, iPPEM);

 	file.Replace(file_session, buffer, EFileShareAny);

 	// Extract global info

 	// STARTFONT 2.2

 	buffer.Format(_L("STARTFONT 2.2\r\n"));

 	FileWrite8(file, buffer);

 	// COMMENT <font name> [(Bold) ][(Italic) ]at <nn> pixels per em

 	buffer.Format(_L("COMMENT %S "), &familyName);

 	FileWrite8(file, buffer);

 	if (iStandardFont->FontSpecInTwips().iFontStyle.StrokeWeight() == EStrokeWeightBold)

 		{

 		buffer.Format(_L("(Bold) "));

 		FileWrite8(file, buffer);

 		}

 	if (iStandardFont->FontSpecInTwips().iFontStyle.Posture() == EPostureItalic)

 		{

 		buffer.Format(_L("(Italic) "));

 		FileWrite8(file, buffer);

 		}

 	buffer.Format(_L("at %d pixels per em\r\n"), iPPEM);

 	FileWrite8(file, buffer);

 	// COMMENT Generated by the EPOC BDF creator

 	buffer.Format(_L("COMMENT Generated by the EPOC BDF creator\r\n"));

 	FileWrite8(file, buffer);

 	// FONT <font name>

 	buffer.Format(_L("FONT %S\r\n"), &iFilename);

 	FileWrite8(file, buffer);

 	// SIZE <ppem> 72 72

 	buffer.Format(_L("SIZE %d 72 72\r\n"), iPPEM);

 	FileWrite8(file, buffer);

 	// FONTBOUNDINGBOX <bbox pixel width> <bbox pixel height> <bbox x pixel offset> <bbox y pixel offset>

 	TInt bbw = fMetrics.MaxWidth();

 	TInt bbh = fMetrics.MaxHeight() + fMetrics.MaxDepth();

 	TInt bbxo = 0;

 	TInt bbyo = -1 * fMetrics.MaxDepth();

 	buffer.Format(_L("FONTBOUNDINGBOX %d %d %d %d\r\n"), bbw, bbh, bbxo, bbyo);

 	FileWrite8(file, buffer);

 	// STARTPROPERTIES

 	TInt numproperties = 5;

 	if (iStandardFont->FontSpecInTwips().iFontStyle.StrokeWeight() == EStrokeWeightBold)

 		numproperties++;

 	if (iStandardFont->FontSpecInTwips().iFontStyle.Posture() == EPostureItalic)

 		numproperties++;

 	buffer.Format(_L("STARTPROPERTIES %d\r\n"), numproperties);

 	FileWrite8(file, buffer);

 	buffer.Format(_L("Uid %S\r\n"), &iUid);

 	FileWrite8(file, buffer);

 	buffer.Format(_L("MaxNormalCharWidth "));

 	FileWrite8(file, buffer);

 	TInt maxWidth = bbw;

 	buffer.Format(_L("%d\r\n"), maxWidth);

 	FileWrite8(file, buffer);

 	buffer.Format(_L("MaxConsecutiveFillChars 5\r\n"));

 	FileWrite8(file, buffer);

 	if (iStandardFont->FontSpecInTwips().iFontStyle.StrokeWeight() == EStrokeWeightBold)

 		{

 		buffer.Format(_L("Bold 1\r\n"));

 		FileWrite8(file, buffer);

 		}

 	if (iStandardFont->FontSpecInTwips().iFontStyle.Posture() == EPostureItalic)

 		{

 		buffer.Format(_L("Italic 1\r\n"));

 		FileWrite8(file, buffer);

 		}

 	// FONT_ASCENT

 	buffer.Format(_L("FONT_ASCENT %d\r\n"), fMetrics.Ascent());

 	FileWrite8(file, buffer);

 	// FONT_DESCENT

 	buffer.Format(_L("FONT_DESCENT %d\r\n"), fMetrics.Descent());

 	FileWrite8(file, buffer);

 	// ENDPROPERTIES

 	buffer.Format(_L("ENDPROPERTIES\r\n"));

 	FileWrite8(file, buffer);

 	// CHARS <number of glyphs>

 	// Work out how many chars in font

 	TInt charCount = 0;

 	TInt i = 0;

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

 		{

 		if ( iStandardFont->HasCharacter(i) )

 			charCount++;

 		}

 	buffer.Format(_L("CHARS %d\r\n"), charCount);

 	FileWrite8(file, buffer);

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

 		{

 		if ( iStandardFont->HasCharacter(i) )

 			{

 			// STARTCHAR <Unn in hex>

 			buffer.Format(_L("STARTCHAR U%x\r\n"), i);

 			FileWrite8(file, buffer);

 			// ENCODING <usually nn decimal>

 			buffer.Format(_L("ENCODING %d\r\n"), i);

 			FileWrite8(file, buffer);

 			// SWIDTH <swidth> 0

 			// DWIDTH <swidth * (pointsize / 1000) * (device resolution / 72)> 0

 			// DWIDTH <swidth * (ppem / 1000) * (72 / 72)> 0

 			// but DWIDTH  = <advance in pixels> which we know

 			// so SWIDTH = (DWIDTH * 1000) / ppem

 			TOpenFontCharMetrics cMetrics;

 			const TUint8* bitmapPtr;

 			TSize dummy;

 			iStandardFont->GetCharacterData(i, cMetrics, bitmapPtr, dummy);

 			TInt dwidth = cMetrics.HorizAdvance();

 			TReal dwidthReal = dwidth;

 			TInt swidth = (TInt)(((dwidthReal * 1000) / iPPEM) + 0.5);

 			buffer.Format(_L("SWIDTH %d 0\r\n"), swidth);

 			FileWrite8(file, buffer);

 			buffer.Format(_L("DWIDTH %d 0\r\n"), dwidth);

 			FileWrite8(file, buffer);

 			// BBX <bmap pixel width> <bmap pixel height> <bmap x pixel offset> <bmap y pixel offset>

 			TInt bpw = cMetrics.Width();

 			TInt bph = cMetrics.Height();

 			TInt bxo = cMetrics.HorizBearingX();

 			TInt byo = cMetrics.HorizBearingY() - bph; // Because openfont offsets are to top left and bdf is to bottom left

 			buffer.Format(_L("BBX %d %d %d %d\r\n"), bpw, bph, bxo, byo);

 			FileWrite8(file, buffer);

 			// BITMAP

 			buffer.Format(_L("BITMAP\r\n"));

 			FileWrite8(file, buffer);

 			TInt paddedWidth = ((bpw + 7) / 8);

 			if (bph * paddedWidth)

 				{

 				TUint8* bitmap = new TUint8 [sizeof(TUint8) * bph * paddedWidth];

 				DecodeBitmap(bpw, paddedWidth, bph, bitmapPtr, bitmap);

 				for (TInt j = 0; j < bph; j++)

 					{

 					// Output one line of bitmap

 #ifndef SHOW_FONT_PICTURES_INSTEAD_OF_HEX

 					// This branch is the standard version that produces useable BDF files

 					for (TInt k = paddedWidth - 1; k >= 0; k--)

 						{

 						TInt byte = *(bitmap + (j * paddedWidth) + k);

 						OutHex(byte / 16);

 						FileWrite8(file, buffer);

 						OutHex(byte % 16);

 						FileWrite8(file, buffer);

 						}

 					buffer.Format(_L("\r\n"));

 					FileWrite8(file, buffer);

 #else

 					// This branch shows the char bitmaps but does not produce useable BDF files

 					buffer.Format(_L("["));

 					FileWrite8(file, buffer);

 					iBitNum = ((j + 1) * paddedWidth * 8) - 1;

 					iBitMap = bitmap;

 					for (TInt k = 0; k < bpw; k++)

 						{

 						if (ReadBitBack())

 							buffer.Format(_L("@"));

 						else

 							buffer.Format(_L(" "));

 						FileWrite8(file, buffer);

 						}

 					for (k = bpw; k < 8 * paddedWidth; k++)

 						{

 						buffer.Format(_L("."));

 						FileWrite8(file, buffer);

 						}

 					buffer.Format(_L("]\r\n"));

 					FileWrite8(file, buffer);

 #endif

 					}

 				delete [] bitmap;

 				}

 			// ENDCHAR

 			buffer.Format(_L("ENDCHAR\r\n"));

 			FileWrite8(file, buffer);

 			}

 		}

 	// ENDFONT

 	buffer.Format(_L("ENDFONT\r\n"));

 	FileWrite8(file, buffer);

 	// Close file

 	file.Flush();

 	file.Close();

 	file_session.Close();

 	}

 TInt CBDFHarness::ReadBit()

 	{

 	TInt val = 1;

 	for (TInt i = 0; i < (iBitNum % 8); i++)

 		val *= 2;

 	val = iBitMap[iBitNum / 8] & val;

 	iBitNum++;

 	return val ? 1 : 0;

 	}

 TInt CBDFHarness::ReadBitBack()

 	{

 	TInt val = 1;

 	for (TInt i = 0; i < (iBitNum % 8); i++)

 		val *= 2;

 	val = iBitMap[iBitNum / 8] & val;

 	iBitNum--;

 	return val ? 1 : 0;

 	}

 void CBDFHarness::OutHex(TInt aOneHexDigit)

 	{

 	if (aOneHexDigit <= 9)

 		buffer.Format(_L("%c"), '0' + aOneHexDigit);

 	else

 		buffer.Format(_L("%c"), 'a' + aOneHexDigit - 10);

 	}

 void CBDFHarness::DecodeBitmap(TInt aWidth, TInt aPaddedWidth, TInt aHeight, const TUint8* aCodedBitmap, TUint8* aBitMap)

 	{

 	// Zero the bitmap

 	for (TInt i = 0; i < aPaddedWidth * aHeight; i++)

 		aBitMap[i] = 0;

 	TInt repeats = 0;

 	iBitNum = 0;

 	iBitMap = aCodedBitmap;

 	for (TInt linesRead = 0; linesRead < aHeight; linesRead += repeats)

 		{

 		TInt repeating = !(ReadBit());

 		// Intended behavior is for the line of code below to be evaluated left to right.

 		//    repeats = (1 * ReadBit()) + (2 * ReadBit()) + (4 * ReadBit()) + (8 * ReadBit());

 		// However, the order in which calls to ReadBit() above are evaluated is undefined,

 		// and is compiler dependent.

 		// The following code ensures that the correct code is used:

 		TInt bit1 = ReadBit();

 		TInt bit2 = ReadBit();

 		TInt bit3 = ReadBit();

 		TInt bit4 = ReadBit();

 		repeats = (1 * bit1) + (2 * bit2) + (4 * bit3) + (8 * bit4);

 		TInt padVal = (aPaddedWidth * 8) - aWidth;

 		if (repeating)

 			{

 			for (TInt j = padVal + aWidth - 1; j >= padVal; j--)

 				{

 				TInt value = ReadBit();

 				for (TInt k = 0; k < (j % 8); k++)

 					value *= 2;

 				for (TInt l = 0; l < repeats; l++)

 					{

 					aBitMap[((linesRead + l) * aPaddedWidth) + (j / 8)] =

 						TUint8(aBitMap[((linesRead + l) * aPaddedWidth) + (j / 8)] + value);

 					}

 				}

 			}

 		else

 			{

 			for (TInt l = 0; l < repeats; l++)

 				{

 				for (TInt j = padVal + aWidth - 1; j >= padVal; j--)

 					{

 					TInt value = ReadBit();

 					for (TInt k = 0; k < (j % 8); k++)

 						value *= 2;

 					aBitMap[((linesRead + l) * aPaddedWidth) + (j / 8)] =

 						TUint8(aBitMap[((linesRead + l) * aPaddedWidth) + (j / 8)] + value);

 					}

 				}

 			}

 		}

 	}