/*

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

* 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()

	{

	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::MakeBDFFont()

	{

	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;

	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);

					}

				}

			}

		}

	}