// 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:

 //

 #include "FONTCOMP.H"

 FontCompiler::FontCompiler():

 	iInputFile(),

 	iOutputFile(),

 	iFxf(NULL),

 	iFontSpace(NULL),

 	iWorkSpace(NULL),

 	iMapSpace(NULL),

 	iWorkSpaceSize(0),

 	iHeaderDataLen(0),

 	iHeaderData()

 	{}

 int FontCompiler::Init(char* infile,char* outfile,char* mapfile)

 	{

 	if(mapfile)

 		{

 		iMapSpace=new short int[256];

 		if(!iMapSpace) return(NoMemory);

 #ifdef __MSVCDOTNET__

 		fstream tempfile(mapfile, ios::in | ios::binary);

 #else //!__MSVCDOTNET__

 		fstream tempfile(mapfile, ios::in | ios::binary | ios::nocreate);

 #endif //__MSVCDOTNET__

 		if(!tempfile.is_open())

 			return(NoFile);

 		tempfile.read((char*)iMapSpace,512);

 		tempfile.close();

 		}

 	iOutputFile.open(outfile, ios::out);

 #ifdef __MSVCDOTNET__

 	iInputFile.open(infile, ios::in | ios::binary);

 #else //!__MSVCDOTNET__

 	iInputFile.open(infile, ios::in | ios::binary | ios::nocreate);

 #endif //__MSVCDOTNET__

 	if(!(iOutputFile.is_open() && iInputFile.is_open()))

 		return(NoFile);

 	iFxf=new Fxf;

 	if(!iFxf) return(NoMemory);

 	iFxf->iBold=0;

 	iFxf->iItalic=0;

 	iFxf->iProportional=0;

 	iFxf->iSerif=0;

 	iFxf->iSymbol=0;

 	iFxf->iUid=0;

 	iFontSpace=new char[0x100000];

 	if(!iFontSpace) return(NoMemory);

 	return(NoError);

 	}

 char* FontCompiler::FontStore() const

 	{

 	return(iFontSpace);

 	}

 int FontCompiler::Read(FontType aInputType)

 	{

 	FontRead *read=NULL;

 	switch(aInputType)

 		{

 		case EFontTypeFsc:

 			read=new FscRead(iInputFile,*this,iFxf);

 			break;

 		case EFontTypeEff:

 			read=new EffRead(iInputFile,*this,iFxf,iMapSpace);

 			break;

 		default:

 			return(Parameter);

 		}

 	if(!read)

 		return(NoMemory);

 	int error=read->ReadFont();

 	delete read;

 	return(error);

 	}

 void FontCompiler::RemoveBlankSpace()

 	{

 	int count=0;

 	const int maxbytewidth=(MAX_CHAR_WID+15)>>3;

 	unsigned char buf[maxbytewidth];

 	unsigned char zbuf[maxbytewidth];

 	for(count=0;count<maxbytewidth;count++)

 			zbuf[count]=0;

 	for(int chNum=iFxf->FirstChr;chNum<iFxf->n_chars;chNum++)

 		{

 		FcmCharHead *fChar=iFxf->chr[chNum];

 		if(fChar)

 		    {

 		    int LastNonBlank=0;

 		    int TopCount=0;

 		    int MinLeftBlank=fChar->width;

 		    int MinRightBlank=0;

        	    // DEF102183: Graphics tools fail to build using MS VC8.

 		    int row;

 		    int x;

 		    for(row=0;row<fChar->height;)

 			{

 				memcpy(buf,iFontSpace+fChar->offset+fChar->ByteWid*row,fChar->ByteWid);

 			unsigned char bit=1;

 			unsigned char* pb=buf;

 			for(x=0;x<MinLeftBlank;x++)

 			    {

 			    if ((*pb)&bit)

 				{

 				MinLeftBlank=x;

 				break;

 				}

 			    bit<<=1;

 			    if (bit==0)

 				{

 				bit=1;

 				pb++;

 				}

 			    }

 			bit=(unsigned char)(1<<((fChar->width-1)%8));

 			pb=&buf[((fChar->width-1)>>3)];

 			for(x=fChar->width;x>MinRightBlank;x--)

 			    {

 			    if ((*pb)&bit)

 				{

 				MinRightBlank=x;

 				break;

 				}

 			    bit>>=1;

 			    if (bit==0)

 				{

 				bit=unsigned char(0x80);

 				pb--;

 				}

 			    }

 			row++;

 				if(memcmp(zbuf,buf,fChar->ByteWid))

 			    {

 			    if (TopCount==0)

 				TopCount=row;   /* Count of blank rows at the top */

 			    LastNonBlank=row;

 			    }

 			}

 		    if (TopCount==0)

 			{

 			fChar->height=0;

 			fChar->width=0;

 			fChar->xOffset=0;

 			fChar->yOffset=0;

 			}

 		    else

 			{

 			TopCount--;

 			fChar->height=LastNonBlank-TopCount;

 			fChar->width=MinRightBlank-MinLeftBlank;

 			fChar->yOffset-=TopCount;

 			fChar->offset+=TopCount*fChar->ByteWid;

 			fChar->xOffset+=MinLeftBlank;

 			if (MinLeftBlank)

 			    {

 			    int byte_step=MinLeftBlank/8;

 			    int bit_shift=MinLeftBlank%8;

 			    unsigned char mask=(unsigned char)(0xFF>>(7-((fChar->width-1)%8)));

 			    for(row=0;row<fChar->height;row++)

 						{

 						memcpy(buf,iFontSpace+fChar->offset+fChar->ByteWid*row,fChar->ByteWid);

 						for(x=0;x<(fChar->ByteWid-byte_step);x++)

 							buf[x]=(unsigned char)((buf[x+byte_step]>>bit_shift)+

 								(buf[x+byte_step+1]<<(8-bit_shift)));

 						buf[x-1]&=mask;

 						memcpy(iFontSpace+fChar->offset+fChar->ByteWid*row,buf,fChar->ByteWid);

 						}

 			    }

 			}

 		    }

 		}

 	}