/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011 Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.

Additional permissions under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK,
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK
(or a modified version of those libraries),
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA,
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the
licensors of this Program grant you additional
permission to convey the resulting work. Corresponding Source for a
non-source form of such a combination shall include the source code for
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered
work.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
///////////////////////////////////////////////////////////////////////////////
//																			 //
//	plFont Class Header														 //
//	Seems like we've come full circle again. This is our generic Plasma		 //
//	bitmap font class/format. Quick list of things it supports, or needs to: //
//		- Antialiasing, either in the font def or at rendertime				 //
//		- Doublebyte character sets											 //
//		- Platform independence, of course									 //
//		- Render to reasonably arbitrary mipmap								 //
//		- Character-level kerning, both before and after, as well as		 //
//		  negative kerning (for ligatures)									 //
//																			 //
//	Cyan, Inc.																 //
//																			 //
//// Version History //////////////////////////////////////////////////////////
//																			 //
//	3.4.2003 mcn - Created.													 //
//	4.3.2003 mcn - Updated. Casting a char to a UInt16 sign-extends it if	 //
//				   the char is > 128, but casting it to an UInt8 first works.//
//				   Ugly as sin, but hey, so are you.						 //
//																			 //
///////////////////////////////////////////////////////////////////////////////

#include "hsTypes.h"
#include "hsStlUtils.h"
#include "plFont.h"

#include "plMipmap.h"
#include "hsResMgr.h"


//// plCharacter Stuff ////////////////////////////////////////////////////////

plFont::plCharacter::plCharacter()
{
	fBitmapOff = 0;
	fHeight = 0;
	fBaseline = 0;
	fLeftKern = fRightKern = 0.f;
}

void	plFont::plCharacter::Read( hsStream *s )
{
	// Rocket science here...
	s->ReadSwap( &fBitmapOff );
	s->ReadSwap( &fHeight );
	s->ReadSwap( &fBaseline );
	s->ReadSwap( &fLeftKern );
	s->ReadSwap( &fRightKern );
}

void	plFont::plCharacter::Write( hsStream *s )
{
	s->WriteSwap( fBitmapOff );
	s->WriteSwap( fHeight );
	s->WriteSwap( fBaseline );
	s->WriteSwap( fLeftKern );
	s->WriteSwap( fRightKern );
}

//// Constructor/Read/Write/Destructor/etc ////////////////////////////////////

plFont::plFont()
{
	IClear( true );
}

plFont::~plFont()
{
	IClear();
}

void	plFont::IClear( bool onConstruct )
{
	if( !onConstruct )
		delete [] fBMapData;

	memset( fFace, 0, sizeof( fFace ) );
	fSize = 0;
	fFlags = 0;

	fWidth = fHeight = 0;
	fBPP = 0;
	fBMapData = nil;
	fFirstChar = 0;
	fMaxCharHeight = 0;
	fCharacters.Reset();

	fRenderInfo.fFlags = 0;
	fRenderInfo.fX = fRenderInfo.fY = fRenderInfo.fNumCols = 0;
	fRenderInfo.fMaxWidth = fRenderInfo.fMaxHeight = 0;
	fRenderInfo.fDestPtr = nil;
	fRenderInfo.fDestStride = 0;
	fRenderInfo.fColor = 0;
	fRenderInfo.fMipmap = nil;
	fRenderInfo.fRenderFunc = nil;
	fRenderInfo.fVolatileStringPtr = nil;
	fRenderInfo.fFirstLineIndent = 0;
	fRenderInfo.fLineSpacing = 0;
}

void	plFont::SetFace( const char *face )
{
	strncpy( fFace, face, sizeof( fFace ) );
}

void	plFont::SetSize( UInt8 size )
{
	fSize = size;
}

void	plFont::Read( hsStream *s, hsResMgr *mgr )
{
	hsKeyedObject::Read( s, mgr );
	ReadRaw( s );
}

void	plFont::Write( hsStream *s, hsResMgr *mgr )
{
	hsKeyedObject::Write( s, mgr );
	WriteRaw( s );
}

///////////////////////////////////////////////////////////////////////////////
//// Rendering ////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

void	plFont::SetRenderColor( UInt32 color )
{
	fRenderInfo.fColor = color;
}

void	plFont::SetRenderClipRect( Int16 x, Int16 y, Int16 width, Int16 height )
{
	fRenderInfo.fClipRect.Set( x, y, width, height );
}

void	plFont::SetRenderClipping( Int16 x, Int16 y, Int16 width, Int16 height )
{
	SetRenderFlag( kRenderWrap, false );
	SetRenderFlag( kRenderClip, true );
	SetRenderClipRect( x, y, width, height );
}

void	plFont::SetRenderWrapping( Int16 x, Int16 y, Int16 width, Int16 height )
{
	SetRenderFlag( kRenderWrap, true );
	SetRenderFlag( kRenderClip, false );
	SetRenderClipRect( x, y, width, height );
}

void	plFont::ICalcFontAscent( void )
{
	UInt32	i;


	// Hack for now, only calc the ascent for characters in the 127 character ASCII range
	for( i = 0, fFontAscent = 0, fFontDescent = 0, fMaxCharHeight = 0; i < fCharacters.GetCount(); i++ )
	{
		if( i + fFirstChar < 128 && fFontAscent < fCharacters[ i ].fBaseline )
			fFontAscent = fCharacters[ i ].fBaseline;

		Int32 descent = fCharacters[ i ].fHeight - fCharacters[ i ].fBaseline;
		if( fFontDescent < descent )
			fFontDescent = descent;

		if( fMaxCharHeight < fCharacters[ i ].fHeight )
			fMaxCharHeight = fCharacters[ i ].fHeight;
	}
}

//// IIsWordBreaker //////////////////////////////////////////////////////////
//	Returns whether the given character is one that can break a line

static inline bool	IIsWordBreaker( const char c )
{
	return ( strchr( " \t,.;\n", c ) != nil ) ? true : false;
}

//// IIsDrawableWordBreak /////////////////////////////////////////////////////
// Returns whether the given character is a line breaker that has to be drawn
// (non whitespace)

static inline bool	IIsDrawableWordBreak( const char c )
{
	return ( strchr( ",.;", c ) != nil ) ? true : false;
}

//// RenderString /////////////////////////////////////////////////////////////
//	The base render function. Additional options are specified externally,
//	so that their effects can be cached for optimization

void	plFont::RenderString( plMipmap *mip, UInt16 x, UInt16 y, const char *string, UInt16 *lastX, UInt16 *lastY )
{
	// convert the char string to a wchar_t string
	wchar_t *wideString = hsStringToWString(string);
	RenderString(mip,x,y,wideString,lastX,lastY);
	delete [] wideString;
}


void	plFont::RenderString( plMipmap *mip, UInt16 x, UInt16 y, const wchar_t *string, UInt16 *lastX, UInt16 *lastY )
{
	if( mip->IsCompressed() )
	{
		hsAssert( false, "Unable to render string to compressed mipmap" );
		return;
	}

	IRenderString( mip, x, y, string, false );
	if( lastX != nil )
		*lastX = fRenderInfo.fLastX;
	if( lastY != nil )
		*lastY = fRenderInfo.fLastY;
}

void	plFont::IRenderString( plMipmap *mip, UInt16 x, UInt16 y, const wchar_t *string, hsBool justCalc )
{
	fRenderInfo.fMipmap = mip;
	fRenderInfo.fX = x;
	fRenderInfo.fY = y;
	fRenderInfo.fNumCols = (Int16)(( fBPP <= 8 ) ? ( ( fWidth * fBPP ) >> 3 ) : 0);
	fRenderInfo.fFloatWidth = (hsScalar)fWidth;
	fRenderInfo.fFarthestX = x;
	fRenderInfo.fMaxAscent = 0;
	fRenderInfo.fVolatileStringPtr = string;

	switch( fRenderInfo.fFlags & kRenderJustYMask )
	{
		case kRenderJustYTop: 
			fRenderInfo.fY += (Int16)fFontAscent; 
			break;
		case kRenderJustYBottom:
			if( fRenderInfo.fFlags & ( kRenderClip | kRenderWrap ) )
				fRenderInfo.fY = (Int16)(fRenderInfo.fClipRect.GetBottom() - 1 - fMaxCharHeight + fFontAscent);
			else
				fRenderInfo.fY = (Int16)(mip->GetHeight() - 1 - fMaxCharHeight + fFontAscent);
			break;
		case kRenderJustYCenter:
			fRenderInfo.fY = (Int16)(( fRenderInfo.fFlags & ( kRenderClip | kRenderWrap ) ) ? fRenderInfo.fClipRect.GetBottom() - 1 : mip->GetHeight() - 1);
			fRenderInfo.fY = (Int16)(( fRenderInfo.fY - fMaxCharHeight ) >> 1);
			fRenderInfo.fY += (Int16)fFontAscent;
			break;
		default:	// Just the baseline
			;
	}

	if( justCalc )
	{
		plCharacter &ch = fCharacters[ (UInt16)string[ 0 ] - fFirstChar ];
		fRenderInfo.fX = fRenderInfo.fFarthestX = x - (Int16)ch.fLeftKern;
		if( fRenderInfo.fX < 0 )
			fRenderInfo.fX = 0;
	}
	else
	{
		switch( fRenderInfo.fFlags & kRenderJustXMask )
		{
			case kRenderJustXLeft:
				// Default
				break;
			case kRenderJustXForceLeft:
				{
//					plCharacter &ch = fCharacters[ (UInt16)(UInt8)string[ 0 ] - fFirstChar ];
//					Int32 newX = x - (Int16)ch.fLeftKern;
//					if( newX < 0 )
//						newX = 0;
//					fRenderInfo.fX = fRenderInfo.fFarthestX = newX;
				}
				break;
			case kRenderJustXCenter:
				{
					UInt16 right = (UInt16)(( fRenderInfo.fFlags & ( kRenderClip | kRenderWrap ) ) ? fRenderInfo.fClipRect.GetRight() : mip->GetWidth());
//					UInt16 width = CalcStringWidth( string );
					fRenderInfo.fX = fRenderInfo.fFarthestX = ( ( x + right ) >> 1 );// - ( width >> 1 );
				}
				break;
			case kRenderJustXRight:
				{
					UInt16 width = 0, right = (UInt16)(( fRenderInfo.fFlags & ( kRenderClip | kRenderWrap ) ) ? fRenderInfo.fClipRect.GetRight() : mip->GetWidth());
/*					if( fRenderInfo.fFlags & kRenderClip )
					{
						fRenderInfo.fFlags &= ~kRenderClip;
						width = CalcStringWidth( string );
						fRenderInfo.fFlags |= kRenderClip;
					}
					else
*/						width = 0;//CalcStringWidth( string );
					fRenderInfo.fX = fRenderInfo.fFarthestX = right - width;
				}
				break;
		}
	}

	// Choose an optimal rendering function
	fRenderInfo.fRenderFunc = nil;
	if( justCalc )
		fRenderInfo.fRenderFunc = &plFont::IRenderCharNull;
	else if( mip->GetPixelSize() == 32 )
	{
		if( fBPP == 1 )
			fRenderInfo.fRenderFunc = ( fRenderInfo.fFlags & kRenderScaleAA ) ? &plFont::IRenderChar1To32AA : &plFont::IRenderChar1To32;
		else if( fBPP == 8 )
		{
			if( fRenderInfo.fFlags & kRenderIntoAlpha )
			{
				if( ( fRenderInfo.fColor & 0xff000000 ) != 0xff000000 )
					fRenderInfo.fRenderFunc = &plFont::IRenderChar8To32Alpha;
				else
					fRenderInfo.fRenderFunc = &plFont::IRenderChar8To32FullAlpha;
			}
			else
				fRenderInfo.fRenderFunc = &plFont::IRenderChar8To32;
		}
	}

	if( fRenderInfo.fRenderFunc == nil )
	{
		hsAssert( false, "Invalid combination of source and destination formats in RenderString()" );
		return;
	}

	// Init our other render values
	if( !justCalc )
	{
		fRenderInfo.fDestStride = mip->GetRowBytes();
		fRenderInfo.fDestBPP = mip->GetPixelSize() >> 3;
		fRenderInfo.fDestPtr = (UInt8 *)mip->GetImage();
		fRenderInfo.fDestPtr += fRenderInfo.fY * fRenderInfo.fDestStride;
		fRenderInfo.fDestPtr += fRenderInfo.fX * fRenderInfo.fDestBPP;
	}
	if( fRenderInfo.fFlags & ( kRenderWrap | kRenderClip ) )
	{
		fRenderInfo.fMaxHeight = (Int16)( fRenderInfo.fClipRect.GetBottom() - fRenderInfo.fY );
		fRenderInfo.fMaxWidth = (Int16)( fRenderInfo.fClipRect.GetRight() - x );
	}
	else if( justCalc )
	{
		// Just calculating, no wrapping, so the max is as far as we can go
		// Note: 32767 isn't quite right, since we'll be adding the left kern in before we
		// calc the first character, so adjust so we make sure we don't underflow
		plCharacter &ch = fCharacters[ (UInt16)(UInt8)string[ 0 ] - fFirstChar ];

		fRenderInfo.fMaxHeight = (Int16)fMaxCharHeight;
		fRenderInfo.fMaxWidth = (Int16)32767 + (Int16)ch.fLeftKern;
	}
	else
	{
		fRenderInfo.fMaxHeight = (Int16)( mip->GetHeight() - fRenderInfo.fY );
		fRenderInfo.fMaxWidth = (Int16)( mip->GetWidth() - x );
	}

	fRenderInfo.fMaxDescent = 0;

	if( fRenderInfo.fFlags & kRenderWrap )
	{
		// Hell, gotta word wrap the text
		// To avoid backtracking, we step forward in the string one word at a time until we hit a break,
		// then render what we have and continue
		Int32 lastWord = 0, i;
		bool isFirstLine = true;
		x = 0;
		Int16 firstMaxAscent = 0;
		UInt32 lineHt, lineDelta;
		if( fRenderInfo.fFlags & kRenderScaleAA )
			lineHt = fMaxCharHeight >> 1;
		else
			lineHt = fMaxCharHeight;
		
		// adjust the line height for spacing
		lineHt += fRenderInfo.fLineSpacing;

		lineDelta = lineHt * fRenderInfo.fDestStride;

		while( *string != 0 && fRenderInfo.fMaxHeight >= fFontDescent )
		{
			UInt8 *destStartPtr = fRenderInfo.fDestPtr;
			UInt32 destStartX = fRenderInfo.fX;
			Int16 destMaxWidth = fRenderInfo.fMaxWidth, thisIndent = 0;

			if( isFirstLine )
			{
				// First line, apply indent if applicable
				fRenderInfo.fX += fRenderInfo.fFirstLineIndent;
				fRenderInfo.fMaxWidth -= fRenderInfo.fFirstLineIndent;
				fRenderInfo.fDestPtr += fRenderInfo.fFirstLineIndent * fRenderInfo.fDestBPP;
				thisIndent = fRenderInfo.fFirstLineIndent;
				isFirstLine = false;
			}

			std::string ellipsisTracker = ""; // keeps track of ellipsis, since there are three word break chars that can't be split
			bool possibleEllipsis = false;
			int preEllipsisLastWord = 0; // where the word break was before we started tracking an ellipsis

			// Iterate through the string, looking for the next line break
			for( lastWord = 0, i = 0; string[ i ] != 0; i++ )
			{
				// If we're a carriage return, we go ahead and break anyway
				if( string[ i ] == L'\n' )
				{
					lastWord = i;
					break;
				}
				
				// handle invalid chars discretely
				plCharacter* charToDraw = NULL;
				if (fCharacters.Count() <= ((UInt16)string[i] - fFirstChar))
					charToDraw = &(fCharacters[(UInt16)L' ' - fFirstChar]);
				else
					charToDraw = &(fCharacters[(UInt16)string[i] - fFirstChar]);

				Int16 leftKern = (Int16)charToDraw->fLeftKern;
				if( fRenderInfo.fFlags & kRenderScaleAA )
					x += leftKern / 2;
				else
					x += leftKern;

				// Update our position and see if we're over
				// Note that our wrapping is slightly off, in that it doesn't take into account
				// the left kerning of characters. Hopefully that won't matter much...
				UInt16 charWidth = (UInt16)(fWidth + (Int16)charToDraw->fRightKern);
				if( fRenderInfo.fFlags & kRenderScaleAA )
					charWidth >>= 1;

				UInt16 nonAdjustedX = (UInt16)(x + fWidth); // just in case the actual bitmap is too big to fit on page and we think the character can (because of right kern)
				x += charWidth;

				if(( x >= fRenderInfo.fMaxWidth ) || (nonAdjustedX >= fRenderInfo.fMaxWidth))
				{
					// we're over, but lastWord may not be correct (especially if we're in the middle of an ellipsis)
					if (possibleEllipsis)
					{
						// ellipsisTracker will not be empty since possibleEllipsis is true (so there will be at least one period)
						if (ellipsisTracker == ".") // only one period so far
						{
							if ((string[i] == '.') && (string[i+1] == '.')) // we have an ellipsis, so reset the lastWord back before we found it
								lastWord = preEllipsisLastWord;
							// otherwise, we don't have an ellipsis, so lastWord is correct (but the grammer might not be ;-)
						}
						else if (ellipsisTracker == "..") // only two periods so far
						{
							if (string[i] == '.') // we have an ellipsis, so reset the lastWord back before we found it
								lastWord = preEllipsisLastWord;
							// otherwise, we don't have an ellipsis, so lastWord is correct (but the grammer might not be ;-)
						}
						// if neither of the above are true, then the full ellipsis was encountered and the lastWord is correct
						ellipsisTracker = "";
						possibleEllipsis = false;
					}
					// Over, so break
					break;
				}

				// Are we a word breaker?
				if( IIsWordBreaker( (char)(string[ i ]) ) )
				{
					if (string[i] == '.') // we might have an ellipsis here
					{
						if (ellipsisTracker == "...") // we already have a full ellipsis, so break between them
						{
							preEllipsisLastWord = i;
							ellipsisTracker = "";
						}
						else if (ellipsisTracker == "") // no ellipsis yet, so save the last word
							preEllipsisLastWord = lastWord;
						ellipsisTracker += '.';
						possibleEllipsis = true;
					}
					else
					{
						ellipsisTracker = ""; // no chance of an ellipsis, so kill it
						possibleEllipsis = false;
					}
					// Yes, and we didn't go over, so store as the last successfully fit word and move on
					lastWord = i;
				}			
			}

			if( string[ i ] == 0 )
				lastWord = i;		// Final catch for end-of-string
			else if( lastWord == 0 && string[ i ] != L'\n' && thisIndent == 0 )
				lastWord = i;		// Catch for a single word that didn't fit (just go up as many chars as we can)
									// (but NOT if we have a first line indent, mind you :)

			// Got to the end of a line (somewhere), so render up to lastWord, then advance from that point
			// to the first non-word-breaker and continue onward
			if( lastWord > 0 )
			{
				bool drawableWordBreak = IIsDrawableWordBreak((char)(string[lastWord]));
				if (drawableWordBreak)
					lastWord++; // make sure we draw it
				if( ( fRenderInfo.fFlags & kRenderJustXMask ) == kRenderJustXRight )
				{
					UInt16 baseX = fRenderInfo.fX, baseMaxW = fRenderInfo.fMaxWidth;
					UInt8 *baseDestPtr = fRenderInfo.fDestPtr;

					fRenderInfo.fX = 0;
					CharRenderFunc oldFunc = fRenderInfo.fRenderFunc;
					fRenderInfo.fRenderFunc = &plFont::IRenderCharNull;

					IRenderLoop( string, lastWord );

					fRenderInfo.fRenderFunc = oldFunc;
					fRenderInfo.fX = baseX - fRenderInfo.fX;
					fRenderInfo.fMaxWidth = baseMaxW;
					fRenderInfo.fDestPtr = baseDestPtr + ( fRenderInfo.fX - baseX ) * fRenderInfo.fDestBPP;

					IRenderLoop( string, lastWord );

					fRenderInfo.fLastX = fRenderInfo.fX;
					fRenderInfo.fLastY = fRenderInfo.fY;
					fRenderInfo.fX = baseX;
				}
				else if( ( fRenderInfo.fFlags & kRenderJustXMask ) == kRenderJustXCenter )
				{
					UInt16 baseX = fRenderInfo.fX, baseMaxW = fRenderInfo.fMaxWidth;
					UInt8 *baseDestPtr = fRenderInfo.fDestPtr;

					fRenderInfo.fX = 0;
					CharRenderFunc oldFunc = fRenderInfo.fRenderFunc;
					fRenderInfo.fRenderFunc = &plFont::IRenderCharNull;

					IRenderLoop( string, lastWord );

					fRenderInfo.fRenderFunc = oldFunc;
					fRenderInfo.fX = baseX - ( fRenderInfo.fX >> 1 );
					fRenderInfo.fMaxWidth = baseMaxW;
					fRenderInfo.fDestPtr = baseDestPtr + ( fRenderInfo.fX - baseX ) * fRenderInfo.fDestBPP;

					IRenderLoop( string, lastWord );

					fRenderInfo.fLastX = fRenderInfo.fX;
					fRenderInfo.fLastY = fRenderInfo.fY;
					fRenderInfo.fX = baseX;
				}
				else if( ( fRenderInfo.fFlags & kRenderJustXMask ) == kRenderJustXForceLeft )
				{
					Int16 baseX = fRenderInfo.fX;

					plCharacter &ch = fCharacters[ (UInt16)string[ 0 ] - fFirstChar ];

					fRenderInfo.fX -= (Int16)ch.fLeftKern;
					fRenderInfo.fDestPtr -= (Int16)ch.fLeftKern * fRenderInfo.fDestBPP;

					IRenderLoop( string, lastWord );
				
					fRenderInfo.fLastX = fRenderInfo.fX;
					fRenderInfo.fLastY = fRenderInfo.fY;
					fRenderInfo.fX = baseX;
				}
				else
				{
					IRenderLoop( string, lastWord );
					fRenderInfo.fLastX = fRenderInfo.fX;
					fRenderInfo.fLastY = fRenderInfo.fY;
				}
				if (drawableWordBreak)
					lastWord--; // reset it
			}


			// Store farthest X for later reference
			if( lastWord > 0 && fRenderInfo.fX > fRenderInfo.fFarthestX )
				fRenderInfo.fFarthestX = fRenderInfo.fX;

			if( firstMaxAscent == 0 )
				firstMaxAscent = fRenderInfo.fMaxAscent;

			x = 0;
			fRenderInfo.fX = (Int16)destStartX;
			fRenderInfo.fDestPtr = destStartPtr;
			fRenderInfo.fMaxWidth = destMaxWidth;
			fRenderInfo.fMaxAscent = 0;

			// Look for the next non-word-breaker. Note that if we have any carriage returns hidden in here, 
			// we'll want to be advancing down even further
			// Advance down
			if( string[ i ] != 0 )
			{
				fRenderInfo.fY += (Int16)lineHt;
				fRenderInfo.fMaxHeight -= (Int16)lineHt;
				fRenderInfo.fDestPtr += lineDelta;
				fRenderInfo.fLastX = fRenderInfo.fX;
				fRenderInfo.fLastY = fRenderInfo.fY;
			}
			for( i = lastWord; string[ i ] != 0 && IIsWordBreaker( (char)(string[ i ]) ) && string[ i ] != L'\n'; i++ )
			{
			}
			// Process any trailing carriage returns as a separate loop b/c we don't want to throw away white space
			// after returns
			for( ; string[ i ] == L'\n'; i++ )
			{
				// Don't process if i==lastWord, since we already did that one
				if( i > lastWord && string[ i ] == L'\n' )
				{
					// Advance down
					fRenderInfo.fY += (Int16)lineHt;
					fRenderInfo.fMaxHeight -= (Int16)lineHt;
					fRenderInfo.fDestPtr += lineDelta;
					fRenderInfo.fLastY = fRenderInfo.fY;
				}
			}

			// Keep going from here!
			string += i;
		}

		fRenderInfo.fMaxAscent = firstMaxAscent;	
		// Final y offset from the last line
		fRenderInfo.fY += (Int16)fFontDescent;

		fRenderInfo.fVolatileStringPtr = string; 
	}
	else
	{
		if( fRenderInfo.fFlags & kRenderClip )
		{
			// Advance left past any clipping area
			CharRenderFunc oldFunc = fRenderInfo.fRenderFunc;
			fRenderInfo.fRenderFunc = &plFont::IRenderCharNull;
			while( fRenderInfo.fX < fRenderInfo.fClipRect.fX && *string != 0 )
			{
				IRenderLoop( string, 1 );
				string++;
			}
			fRenderInfo.fRenderFunc = oldFunc;
		}

		// Adjust for left kern
		if( ( fRenderInfo.fFlags & kRenderJustXMask ) == kRenderJustXForceLeft )
		{
			// See note at top of file
			plCharacter &ch = fCharacters[ (UInt16)string[ 0 ] - fFirstChar ];
			Int32 newX = x - (Int16)ch.fLeftKern;
			if( newX < 0 )
				newX = 0;
			fRenderInfo.fX = fRenderInfo.fFarthestX = (Int16)newX;
		}

		fRenderInfo.fVolatileStringPtr = string;	// Just so we can keep track of when we clip
		IRenderLoop( string, -1 );
		fRenderInfo.fFarthestX = fRenderInfo.fX;
	}
}

void	plFont::IRenderLoop( const wchar_t *string, Int32 maxCount )
{
	// Render the string straight across, one char at a time
	while( *string != 0 && maxCount != 0 )	// Note: if maxCount starts out -1, then it'll just keep 
	{										// decrementing...well ok, not for forever, but pretty close
		UInt16 c = (UInt16)*string;
		if( c < fFirstChar )
			;		// Invalid char
		else
		{
			c -= fFirstChar;
			if( c >= fCharacters.GetCount() )
				;	// Invalid char
			else
			{
				// First pass at supporting left kerning values, but only at the pixel level
				Int16 leftKern = (Int16)fCharacters[ c ].fLeftKern;
				if( leftKern != 0 )
				{
					if( fRenderInfo.fFlags & kRenderScaleAA )
						leftKern /= 2;

					fRenderInfo.fX += leftKern;
					fRenderInfo.fMaxWidth -= leftKern;
					fRenderInfo.fDestPtr += leftKern * fRenderInfo.fDestBPP;
				}

				UInt16 thisWidth = (UInt16)(fWidth + fCharacters[ c ].fRightKern);
				if( fRenderInfo.fFlags & kRenderScaleAA )
					thisWidth >>= 1;

				if( thisWidth >= fRenderInfo.fMaxWidth )
					break;

				(this->*(fRenderInfo.fRenderFunc))( fCharacters[ c ] );

				fRenderInfo.fX += thisWidth;
				fRenderInfo.fMaxWidth -= thisWidth;
				fRenderInfo.fDestPtr += thisWidth * fRenderInfo.fDestBPP;


				Int16 baseline = (Int16)(fCharacters[ c ].fBaseline);
				if( fRenderInfo.fFlags & kRenderScaleAA )
					baseline >>= 1;

				if( baseline > fRenderInfo.fMaxAscent )
					fRenderInfo.fMaxAscent = baseline;

				Int16 thisHt = (Int16)(fCharacters[ c ].fHeight - baseline);
				if( fRenderInfo.fMaxDescent < thisHt )
					fRenderInfo.fMaxDescent = thisHt;
			}
		}

		string++;
		fRenderInfo.fVolatileStringPtr++;
		maxCount--;
	}
}

//// The Rendering Functions //////////////////////////////////////////////////

void	plFont::IRenderChar1To32( const plFont::plCharacter &c )
{
	UInt8	bitMask, *src = fBMapData + c.fBitmapOff;
	UInt32	*destPtr, *destBasePtr = (UInt32 *)( fRenderInfo.fDestPtr - c.fBaseline * fRenderInfo.fDestStride );
	UInt16	x, y;

	
	if( (Int32)c.fHeight - (Int32)c.fBaseline >= fRenderInfo.fMaxHeight || c.fBaseline > fRenderInfo.fY )
		return;

	for( y = 0; y < c.fHeight; y++ )
	{
		destPtr = destBasePtr;
		if( fRenderInfo.fFlags & kRenderItalic )
		{
			// Faux italic
			destPtr += ( c.fHeight - y ) >> 1;
		}

		for( x = 0; x < fRenderInfo.fNumCols; x++ )
		{
			for( bitMask = 0x80; bitMask != 0; bitMask >>= 1 )
			{	
				if( *src & bitMask )
					*destPtr = fRenderInfo.fColor;
				destPtr++;
			}
			src++;
		}
		destBasePtr = (UInt32 *)( (UInt8 *)destBasePtr + fRenderInfo.fDestStride );
	}
}

void	plFont::IRenderChar1To32AA( const plFont::plCharacter &c )
{
	UInt8	bitMask, *src = fBMapData + c.fBitmapOff;
	UInt32	*destPtr, *destBasePtr = (UInt32 *)( fRenderInfo.fDestPtr - ( c.fBaseline >> 1 ) * fRenderInfo.fDestStride );
	UInt16	x, y;

	
	if( ( ( (Int32)c.fHeight - (Int32)c.fBaseline ) >> 1 ) >= fRenderInfo.fMaxHeight || ( c.fBaseline >> 1 ) > fRenderInfo.fY )
		return;

	for( y = 0; y < c.fHeight; y += 2 )
	{
		destPtr = destBasePtr;
		if( fRenderInfo.fFlags & kRenderItalic )
		{
			// Faux italic
			destPtr += ( c.fHeight - y ) >> 2;
		}

		for( x = 0; x < fRenderInfo.fNumCols; x++ )
		{
			for( bitMask = 0x80; bitMask != 0; bitMask >>= 2 )
			{	
				// Grab 4 bits and do 4-to-1 AA
				UInt8 value = ( *src & bitMask ) ? 1 : 0;
				value += ( *src & ( bitMask >> 1 ) ) ? 1 : 0;
				value += ( src[ fRenderInfo.fNumCols ] & bitMask ) ? 1 : 0;
				value += ( src[ fRenderInfo.fNumCols ] & ( bitMask >> 1 ) ) ? 1 : 0;

				switch( value )
				{
					case 1:
					{
						UInt32 src = ( fRenderInfo.fColor >> 2 ) & 0x3f3f3f3f;
						UInt32 dst = ( (*destPtr) >> 2 ) & 0x3f3f3f3f;
						*destPtr = src + dst + dst + dst;					
						break;
					}
					case 2:
					{
						UInt32 src = ( fRenderInfo.fColor >> 1 ) & 0x7f7f7f7f;
						UInt32 dst = ( (*destPtr) >> 1 ) & 0x7f7f7f7f;
						*destPtr = src + dst;
						break;
					}
					case 3:
					{
						UInt32 src = ( fRenderInfo.fColor >> 2 ) & 0x3f3f3f3f;
						UInt32 dst = ( (*destPtr) >> 2 ) & 0x3f3f3f3f;
						*destPtr = src + src + src + dst;
						break;
					}
					case 4:
						*destPtr = fRenderInfo.fColor;
				}

				destPtr++;
			}
			src++;
		}
		destBasePtr = (UInt32 *)( (UInt8 *)destBasePtr + fRenderInfo.fDestStride );
		src += fRenderInfo.fNumCols;
	}
}

void	plFont::IRenderChar8To32( const plFont::plCharacter &c )
{
	UInt8	*src = fBMapData + c.fBitmapOff;
	UInt32	*destPtr, *destBasePtr = (UInt32 *)( fRenderInfo.fDestPtr - c.fBaseline * fRenderInfo.fDestStride );
	UInt16	x, y;
	UInt32	srcAlpha, oneMinusAlpha, r, g, b, dR, dG, dB, destAlpha, thisWidth;
	UInt8	srcR, srcG, srcB;


	// Unfortunately for some fonts, their right kern value actually is
	// farther left than the right edge of the bitmap (think of overlapping
	// script fonts). Ideally, we should store the actual width of each char's
	// bitmap and use that here. However, it really shouldn't make too big of a
	// difference, especially since the dest pixels that we end up overlapping
	// should already be in the cache. If it does, time to upgrade the font
	// format (again)
	thisWidth = fWidth;// + (Int32)c.fRightKern;

	if( (Int32)c.fHeight - (Int32)c.fBaseline >= fRenderInfo.fMaxHeight || thisWidth >= fRenderInfo.fMaxWidth || c.fBaseline > fRenderInfo.fY )
		return;

	srcR = (UInt8)(( fRenderInfo.fColor >> 16 ) & 0x000000ff);
	srcG = (UInt8)(( fRenderInfo.fColor >> 8  ) & 0x000000ff);
	srcB = (UInt8)(( fRenderInfo.fColor       ) & 0x000000ff);

	for( y = 0; y < c.fHeight; y++ )
	{
		destPtr = destBasePtr;
		for( x = 0; x < thisWidth; x++ )
		{
			if( src[ x ] == 255 )
				destPtr[ x ] = fRenderInfo.fColor;
			else if( src[ x ] == 0 )
				;	// Empty
			else
			{
				srcAlpha = ( src[ x ] * ( fRenderInfo.fColor >> 24 ) ) / 255;
				oneMinusAlpha = 255 - srcAlpha;

				destAlpha = destPtr[ x ] & 0xff000000;

				dR = ( destPtr[ x ] >> 16 ) & 0x000000ff;
				dG = ( destPtr[ x ] >> 8  ) & 0x000000ff;
				dB = ( destPtr[ x ]       ) & 0x000000ff;
				r = ( srcR * srcAlpha ) >> 8;
				g = ( srcG * srcAlpha ) >> 8;
				b = ( srcB * srcAlpha ) >> 8;
				dR = ( dR * oneMinusAlpha ) >> 8;
				dG = ( dG * oneMinusAlpha ) >> 8;
				dB = ( dB * oneMinusAlpha ) >> 8;

				destPtr[ x ] = ( ( r + dR ) << 16 ) | ( ( g + dG ) << 8 ) | ( b + dB ) | destAlpha;
			}
		}
		destBasePtr = (UInt32 *)( (UInt8 *)destBasePtr + fRenderInfo.fDestStride );
		src += fWidth;
	}
}

void	plFont::IRenderChar8To32FullAlpha( const plFont::plCharacter &c )
{
	UInt8	*src = fBMapData + c.fBitmapOff;
	UInt32	*destPtr, *destBasePtr = (UInt32 *)( fRenderInfo.fDestPtr - c.fBaseline * fRenderInfo.fDestStride );
	UInt16	x, y;
	UInt32	destColorOnly, thisWidth;


	// Unfortunately for some fonts, their right kern value actually is
	// farther left than the right edge of the bitmap (think of overlapping
	// script fonts). Ideally, we should store the actual width of each char's
	// bitmap and use that here. However, it really shouldn't make too big of a
	// difference, especially since the dest pixels that we end up overlapping
	// should already be in the cache. If it does, time to upgrade the font
	// format (again)
	thisWidth = fWidth;// + (Int32)c.fRightKern;

	if( (Int32)c.fHeight - (Int32)c.fBaseline  >= fRenderInfo.fMaxHeight || thisWidth >= fRenderInfo.fMaxWidth || c.fBaseline > fRenderInfo.fY )
		return;

	destColorOnly = fRenderInfo.fColor & 0x00ffffff;

	for( y = 0; y < c.fHeight; y++ )
	{
		destPtr = destBasePtr;
		for( x = 0; x < thisWidth; x++ )
		{
			if( src[ x ] != 0 )
				destPtr[ x ] = ( src[ x ] << 24 ) | destColorOnly;
		}
		destBasePtr = (UInt32 *)( (UInt8 *)destBasePtr + fRenderInfo.fDestStride );
		src += fWidth;
	}
}

void	plFont::IRenderChar8To32Alpha( const plFont::plCharacter &c )
{
	UInt8	val, *src = fBMapData + c.fBitmapOff;
	UInt32	*destPtr, *destBasePtr = (UInt32 *)( fRenderInfo.fDestPtr - c.fBaseline * fRenderInfo.fDestStride );
	UInt16	x, y;
	UInt32	destColorOnly, alphaMult, fullAlpha, thisWidth;


	// Unfortunately for some fonts, their right kern value actually is
	// farther left than the right edge of the bitmap (think of overlapping
	// script fonts). Ideally, we should store the actual width of each char's
	// bitmap and use that here. However, it really shouldn't make too big of a
	// difference, especially since the dest pixels that we end up overlapping
	// should already be in the cache. If it does, time to upgrade the font
	// format (again)
	thisWidth = fWidth;// + (Int32)c.fRightKern;

	if( (Int32)c.fHeight - (Int32)c.fBaseline  >= fRenderInfo.fMaxHeight || thisWidth >= fRenderInfo.fMaxWidth || c.fBaseline > fRenderInfo.fY )
		return;

	destColorOnly = fRenderInfo.fColor & 0x00ffffff;
	// alphaMult should come out to be a value to satisfy (fontAlpha * alphaMult >> 8) as the right alpha,
	// but then we want it so (fontAlpha * alphaMult) will be in the upper 8 bits
	fullAlpha = fRenderInfo.fColor & 0xff000000;
	alphaMult = fullAlpha / 255;

	for( y = 0; y < c.fHeight; y++ )
	{
		destPtr = destBasePtr;
		for( x = 0; x < thisWidth; x++ )
		{
			val = src[ x ];
			if( val == 0xff )
				destPtr[ x ] = fullAlpha | destColorOnly;
			else if( val != 0 )
			{
				destPtr[ x ] = ( ( alphaMult * val ) & 0xff000000 ) | destColorOnly;
			}
		}
		destBasePtr = (UInt32 *)( (UInt8 *)destBasePtr + fRenderInfo.fDestStride );
		src += fWidth;
	}
}


void	plFont::IRenderCharNull( const plCharacter &c )
{
}

//// CalcString Variations ////////////////////////////////////////////////////

UInt16	plFont::CalcStringWidth( const char *string )
{
	UInt16 w, h, a, lX, lY;
	UInt32 s;
	CalcStringExtents( string, w, h, a, s, lX, lY );
	return w;
}

UInt16	plFont::CalcStringWidth( const wchar_t *string )
{
	UInt16 w, h, a, lX, lY;
	UInt32 s;
	CalcStringExtents( string, w, h, a, s, lX, lY );
	return w;
}

void	plFont::CalcStringExtents( const char *string, UInt16 &width, UInt16 &height, UInt16 &ascent, UInt32 &firstClippedChar, UInt16 &lastX, UInt16 &lastY )
{
	// convert the char string to a wchar_t string
	wchar_t *wideString = hsStringToWString(string);
	CalcStringExtents(wideString,width,height,ascent,firstClippedChar,lastX,lastY);
	delete [] wideString;
}

void	plFont::CalcStringExtents( const wchar_t *string, UInt16 &width, UInt16 &height, UInt16 &ascent, UInt32 &firstClippedChar, UInt16 &lastX, UInt16 &lastY )
{
	IRenderString( nil, 0, 0, string, true );
	width = fRenderInfo.fFarthestX;
	height = (UInt16)(fRenderInfo.fY + fFontDescent);//fRenderInfo.fMaxDescent;
	ascent = fRenderInfo.fMaxAscent;
	lastX = fRenderInfo.fLastX;
	lastY = fRenderInfo.fLastY;

	// firstClippedChar is an index into the given string that points to the start of the part of the string
	// that got clipped (i.e. not rendered).
	firstClippedChar = (UInt32)fRenderInfo.fVolatileStringPtr - (UInt32)string;
	firstClippedChar /= 2; // divide by 2 because a wchar_t is two bytes wide, instead of one (like a char)
}

//// IGetFreeCharData /////////////////////////////////////////////////////////
//	Used for constructing fonts one character at a time; finds a pointer to
//	the first free space in our allocated font bitmap, based on the heights
//	and offsets of all the current characters

UInt8	*plFont::IGetFreeCharData( UInt32 &newOffset )
{
	Int32 i;


	newOffset = 0;
	for( i = fCharacters.GetCount() - 1; i >= 0; i-- )
	{
		UInt32 thisOff = fCharacters[ i ].fBitmapOff + ( ( fCharacters[ i ].fHeight * fWidth * fBPP ) >> 3 );
		if( newOffset < thisOff )
		{
			newOffset = thisOff;
			break;
		}
	}

	if( newOffset >= ( ( fWidth * fHeight * fBPP ) >> 3 ) )
	{
		hsAssert( false, "Invalid position found in IGetFreeCharData()" );
		return nil;
	}

	// Return pointer to the new area
	return fBMapData + newOffset;
}

//// LoadFromP2FFile //////////////////////////////////////////////////////////
//	Handy quick wrapper 

hsBool	plFont::LoadFromP2FFile( const char *path )
{
	hsUNIXStream	stream;
	if( stream.Open( path, "rb" ) )
	{
		ReadRaw( &stream );
		return true;
	}
	return false;
}

//// LoadFromFNT //////////////////////////////////////////////////////////////
//	Load this font from the data found in the given Windows FNT file,
//	using the format specified in the Windows 3 Developers Notes.

hsBool	plFont::LoadFromFNT( const char *path )
{
	hsUNIXStream	stream;		// Ahh, irony
	if( !stream.Open( path, "rb" ) )
		return false;

	return LoadFromFNTStream( &stream );
}

hsBool	plFont::LoadFromFNTStream( hsStream *stream )
{
	IClear();

	try
	{

		// Note: hsUNIXStreams just happen to store in the same endian as Windows...
		struct FNTInfo
		{
			UInt16	version;
			UInt32	size;
			char	copyright[ 60 ];
			UInt16	type;
			UInt16	points;
			UInt16	vertRes;
			UInt16	horzRes;
			UInt16	ascent;
			UInt16	internalLeading;
			UInt16	externalLeading;
			UInt8	italic, underline, strikeout;
			UInt16	weight;
			UInt8	charSet;
			UInt16	pixWidth; // 0 means variable width chars
			UInt16	pixHeight;
			UInt8	pitchFamily;
			UInt16	avgWidth;
			UInt16	maxWidth;
			UInt8	firstChar, lastChar, defaultChar, breakChar;
			UInt16	widthBytes;
			UInt32	device, face;
			UInt32	bitsPointer, bitsOffset;
			UInt8	reserved;
			UInt32	flags;
			UInt16	aSpace, bSpace, cSpace;
			UInt32	colorPointer;
			UInt8	reserved1[ 16 ];

			void	Read( hsStream *s )
			{
				version = s->ReadSwap16();
				size = s->ReadSwap32();

				s->Read( sizeof( copyright ), copyright );
			
				s->ReadSwap( &type );
				s->ReadSwap( &points );
				s->ReadSwap( &vertRes );
				s->ReadSwap( &horzRes );
				s->ReadSwap( &ascent );
				s->ReadSwap( &internalLeading );
				s->ReadSwap( &externalLeading );
				s->ReadSwap( &italic );
				s->ReadSwap( &underline );
				s->ReadSwap( &strikeout );
				s->ReadSwap( &weight );
				s->ReadSwap( &charSet );
				s->ReadSwap( &pixWidth );
				s->ReadSwap( &pixHeight );
				s->ReadSwap( &pitchFamily );
				s->ReadSwap( &avgWidth );
				s->ReadSwap( &maxWidth );
				s->ReadSwap( &firstChar );
				s->ReadSwap( &lastChar );
				s->ReadSwap( &defaultChar );
				s->ReadSwap( &breakChar );
				s->ReadSwap( &widthBytes );
				s->ReadSwap( &device );
				s->ReadSwap( &face );
				s->ReadSwap( &bitsPointer );
				s->ReadSwap( &bitsOffset );
				s->ReadSwap( &reserved );
				if( version == 0x0300 )
				{
					s->ReadSwap( &flags );
					s->ReadSwap( &aSpace );
					s->ReadSwap( &bSpace );
					s->ReadSwap( &cSpace );
					s->ReadSwap( &colorPointer );
					s->Read( sizeof( reserved1 ), reserved1 );
				}
				else
				{
					flags = 0;
					aSpace = bSpace = cSpace = 0;
					colorPointer = 0;
				}
			}
		} fntInfo;

		fntInfo.Read( stream );

		struct charEntry
		{
			UInt16	width;
			UInt32	offset;
			charEntry() { width = 0; offset = 0; }
		} *charEntries;

		int i, count = fntInfo.lastChar - fntInfo.firstChar + 2;
		charEntries = TRACKED_NEW charEntry[ count ];
		for( i = 0; i < count; i++ )
		{
			charEntries[ i ].width = stream->ReadSwap16();
			if( fntInfo.version == 0x0200 )
				charEntries[ i ].offset = stream->ReadSwap16();
			else
				charEntries[ i ].offset = stream->ReadSwap32();
		}

		char faceName[ 256 ], deviceName[ 256 ];
		if( fntInfo.face != 0 )
		{
			stream->SetPosition( fntInfo.face );
			for( i = 0; i < 256; i++ )
			{
				faceName[ i ] = stream->ReadByte();
				if( faceName[ i ] == 0 )
					break;
			}
			strncpy( fFace, faceName, sizeof( fFace ) );
		}
		if( fntInfo.device != 0 )
		{
			stream->SetPosition( fntInfo.device );
			for( i = 0; i < 256; i++ )
			{
				deviceName[ i ] = stream->ReadByte();
				if( deviceName[ i ] == 0 )
					break;
			}
		}
		fSize = (UInt8)(fntInfo.points);

		// Figure out what we need to allocate our bitmap as
		fWidth = 0;
		fHeight = 0;
		for( i = 0; i < count; i++ )
		{
			if( fWidth < charEntries[ i ].width )
				fWidth = charEntries[ i ].width;
			if( charEntries[ i ].offset > 0 )
				fHeight += fntInfo.pixHeight;
		}
		fBPP = 1;

		// Since we're 1 bbp, make sure width is a multiple of 8
		fWidth = ( ( fWidth + 7 ) >> 3 ) << 3;

		UInt32 widthInBytes = ( fWidth * fBPP ) >> 3;

		// Allocate our bitmap now
		UInt32 size = widthInBytes * fHeight;
		fBMapData = TRACKED_NEW UInt8[ size ];
		memset( fBMapData, 0, size );

		fFirstChar = fntInfo.firstChar;
		fMaxCharHeight = 0;

		// Read the bitmap info
		UInt32 destOff = 0;
		for( i = 0; i < count; i++ )
		{
			int numCols = ( charEntries[ i ].width + 7 ) >> 3;
			int height = fntInfo.pixHeight;

			// Write a record for this char
			plCharacter outChar;
			outChar.fBitmapOff = destOff;
			outChar.fHeight = ( charEntries[ i ].offset == 0 ) ? 0 : height;
			outChar.fBaseline = fntInfo.ascent;
			outChar.fLeftKern = 0.f;
			outChar.fRightKern = (hsScalar)(charEntries[ i ].width - fWidth);
			fCharacters.Append( outChar );

			if( outChar.fHeight > fMaxCharHeight )
				fMaxCharHeight = outChar.fHeight;

			if( charEntries[ i ].offset == 0 )
				continue;

			// Seek to this char
			stream->SetPosition( charEntries[ i ].offset );

			// Write the actual bitmap data. Note: FNTs store the bits one column at a time,
			// one col after another, whereas we want it plain row by row
			int col, y;
			UInt8 *basePtr = fBMapData + destOff;
			for( col = 0; col < numCols; col++ )
			{
				UInt8 *yPtr = basePtr;
				for( y = 0; y < height; y++ )
				{
					*yPtr = stream->ReadByte();
					yPtr += widthInBytes;
				}
				basePtr++;
			}

			destOff += widthInBytes * outChar.fHeight;
		}

		delete [] charEntries;

		ICalcFontAscent();
		return true;
	}
	catch( ... )
	{
		// Somehow we crashed converting!
		IClear();
		return false;
	}
}

//// LoadFromBDF //////////////////////////////////////////////////////////////
//	Load this font from the data found in the given Adobe Systems BDF file,
//	using the format specified in the Glyph Bitmap Distribution Format (BDF)
//	Specification Version 2.2 from Adobe Systems.

/*hsBool	plFont::LoadFromBDF( const char *path, plBDFConvertCallback *callback )
{
	hsUNIXStream	stream;		// Ahh, irony
	if( !stream.Open( path, "rb" ) )
		return false;

	return LoadFromBDFStream( &stream, callback );
}
*/
// Some parsing helpers
typedef int	(*fnCharTester)( int );

static int sQuoteTester( int c )
{
	return ( c == '\"' );
}

static int sDashTester( int c )
{
	return isspace( c ) || ( c == '-' );
}

class plLineParser
{
	protected:
		static char	fLine[ 512 ];

		char	*fCursor, fRestore;

		void		IAdvanceToNextToken( fnCharTester tester = isspace )
		{
			// Last cursor
			*fCursor = fRestore;

			// Scan for the start of the next token
			while( *fCursor != 0 && (*tester)( *fCursor ) )
				fCursor++;

			if( *fCursor == 0 )
				return;

			// This is the start of our token
			const char *start = fCursor;

			// Put a stopper here
			fRestore = *fCursor;
			*fCursor = 0;

			// And return!
			return;
		}

		const char	*IGetNextToken( fnCharTester tester = isspace )
		{
			// Last cursor
			*fCursor = fRestore;

			// Scan for the start of the next token
			while( *fCursor != 0 && (*tester)( *fCursor ) )
				fCursor++;

			if( *fCursor == 0 )
				return nil;

			// This is the start of our token; find the end
			const char *start = fCursor;
			while( *fCursor != 0 && !(*tester)( *fCursor ) )
				fCursor++;

			// Put a stopper here
			fRestore = *fCursor;
			*fCursor = 0;

			// And return!
			return start;
		}

	public:

		plLineParser( const char *line )
		{
			strncpy( fLine, line, sizeof( fLine ) );
			fCursor = fLine;
			fRestore = *fCursor;
		}

		~plLineParser() { }

		const char	*GetKeyword( void )
		{
			return IGetNextToken();
		}

		const char	*GetString( void )
		{
			IAdvanceToNextToken();
			return IGetNextToken( sQuoteTester );
		}

		const char	*GetKeywordNoDashes( void )
		{
			return IGetNextToken( sDashTester );
		}

		Int32		GetInt( void )
		{
			return atoi( IGetNextToken() );
		}

		hsScalar	GetFloat( void )
		{
			return (hsScalar)atof( IGetNextToken() );
		}
};

char	plLineParser::fLine[ 512 ];


// Another helper--parser for various sections of the BDF format
class plBDFSectParser
{
	protected:
		plFont					&fFont;
		plBDFConvertCallback	*fCallback;

	public:
		plBDFSectParser( plFont &myFont, plBDFConvertCallback *callback ) : fFont( myFont ), fCallback( callback ) {}

		virtual plBDFSectParser *ParseKeyword( const char *keyword, plLineParser &line )
		{
			return nil;
		}
};


class plBDFLookForEndCharParser : public plBDFSectParser
{
	public:
		plBDFLookForEndCharParser( plFont &myFont, plBDFConvertCallback *callback ) : plBDFSectParser( myFont, callback ) {}

		virtual plBDFSectParser *ParseKeyword( const char *keyword, plLineParser &line );
};

inline UInt8	iHexCharToByte( char c )
{
	switch( c )
	{
		case '0': return 0;
		case '1': return 1;
		case '2': return 2;
		case '3': return 3;
		case '4': return 4;
		case '5': return 5;
		case '6': return 6;
		case '7': return 7;
		case '8': return 8;
		case '9': return 9;
		case 'a': case 'A': return 10;
		case 'b': case 'B': return 11;
		case 'c': case 'C': return 12;
		case 'd': case 'D': return 13;
		case 'e': case 'E': return 14;
		case 'f': case 'F': return 15;
		default: return 0;
	}
}
inline UInt8	iHexStringToByte( const char *str )
{
	return ( iHexCharToByte( str[ 0 ] ) << 4 ) | iHexCharToByte( str[ 1 ] );
}

class plBDFCharsParser : public plBDFSectParser
{
	protected:

		// Info about the current character we're translating
		UInt16				fWhichChar, fRowsLeft;
		plFont::plCharacter	*fCharacter;
		UInt8				*fBitmap;
		hsBool				fDoingData;
		UInt32				fBytesWide, fBMapStride;

		inline void	IReset( void )
		{
			fBitmap = nil;
			fCharacter = nil;
			fWhichChar = 0;
			fDoingData = false;
		}

	public:
		static UInt32		fResolution;

		plBDFCharsParser( plFont &myFont, plBDFConvertCallback *callback ) : plBDFSectParser( myFont, callback ), fDoingData( false ) {}

		virtual plBDFSectParser *ParseKeyword( const char *keyword, plLineParser &line )
		{
			if( strcmp( keyword, "ENDFONT" ) == 0 )
			{
				// All done!
				return nil;
			}
			else if( strcmp( keyword, "ENDCHAR" ) == 0 )
			{
				// End of the character, reset
				IReset();
				if( fCallback != nil )
					fCallback->CharDone();
			}
			else if( fDoingData )
			{
				// If we're doing data, all lines are hex values until we hit "ENDCHAR"
				if( fRowsLeft == 0 )
					throw;

				int hDigit;
				for( hDigit = 0; *keyword != 0 && hDigit < fBytesWide; hDigit++, keyword += 2 )
				{
					*fBitmap = iHexStringToByte( keyword );
					fBitmap++;
				}

				fBitmap += fBMapStride - hDigit;
				fRowsLeft--;
			}
			else if( strcmp( keyword, "STARTCHAR" ) == 0 )
			{
				// Start of a new character--ignore the name, we'll just use the encoding
				IReset();
			}
			else if( strcmp( keyword, "ENCODING" ) == 0 )
			{
				int ch = line.GetInt();
				if( ch == -1 )
				{
					// Nonstandard encoding, skip the character entirely
					return TRACKED_NEW plBDFLookForEndCharParser( fFont, fCallback );
				}
				else
				{
					fWhichChar = (UInt16)(UInt8)ch;

					// Set up our pointer. Note that since BDFs don't tell us the starting character,
					// we just make it 0
					if( fFont.fCharacters.GetCount() < fWhichChar + 1 )
						fFont.fCharacters.SetCount( fWhichChar + 1 );

					fCharacter = &fFont.fCharacters[ fWhichChar ];
				}
			}
			// Horizontal mode offsets (writing mode 0)
			else if( strcmp( keyword, "SWIDTH" ) == 0 )
			{
				// In device units, unused
//				float fWidth = (float)line.GetInt() * ( (float)fFont.GetSize() / 1000.f ) * ( fResolution / 72.f );
//				fCharacter->fRightKern = fWidth - (float)fFont.fWidth;
//				fCharacter->fLeftKern = 0.f;
			}
			else if( strcmp( keyword, "DWIDTH" ) == 0 )
			{
				// In pixels, basically the offset to the next char. Note that we only
				// support the X direction (altho admittedly the idea of a font whose characters cause
				// the next chars to go up or down is way nifty)
				fCharacter->fRightKern = (float)line.GetInt() - (float)fFont.fWidth;
				fCharacter->fLeftKern = 0.f;
			}
			// Vertical mode offsets (unsupported)
			else if( strcmp( keyword, "SWIDTH1" ) == 0 )
			{

			}
			else if( strcmp( keyword, "DWIDTH1" ) == 0 )
			{

			}
			// Bitmap bounding box
			else if( strcmp( keyword, "BBX" ) == 0 )
			{
				int pixW = line.GetInt();
				int pixH = line.GetInt();
				int xOff = line.GetInt();
				int yOff = line.GetInt();

				// Got enough info now to allocate us a bitmap for this char
				fBitmap = fFont.IGetFreeCharData( fCharacter->fBitmapOff );
				if( fBitmap == nil )
					throw false;

				if( fCharacter->fBitmapOff > ( ( fFont.fWidth * ( fFont.fHeight - pixH ) * fFont.fBPP ) >> 3 ) )
				{
					hsAssert( false, "Invalid position found in IGetFreeCharData()" );
					return nil;
				}

				// Set these now, since setting them before would've changed the IGetFreeCharData results
				fCharacter->fLeftKern = (hsScalar)xOff;
				fCharacter->fBaseline = yOff + pixH;
				fCharacter->fHeight = fRowsLeft = pixH;

				fBytesWide = ( pixW + 7 ) >> 3;
				fBMapStride = fFont.fWidth >> 3;
			}
			// Bitmap data
			else if( strcmp( keyword, "BITMAP" ) == 0 )
			{
				fDoingData = true;
			}
			// This keyword is outputted from the "getbdf" utility on linux, for some reason...
			else if( strcmp( keyword, "ATTRIBUTES" ) == 0 )
			{

			}
			else
				throw false;		// Invalid keyword

			return this;
		}
};

UInt32 plBDFCharsParser::fResolution = 72;


plBDFSectParser *plBDFLookForEndCharParser::ParseKeyword( const char *keyword, plLineParser &line )
{
	if( strcmp( keyword, "ENDCHAR" ) == 0 )
	{
		// Horray!
		return TRACKED_NEW plBDFCharsParser( fFont, fCallback );
	}
	// Just gobble lines until we find the endchar section
	return this;
}

class plBDFLookForCharParser : public plBDFSectParser
{
	public:
		plBDFLookForCharParser( plFont &myFont, plBDFConvertCallback *callback ) : plBDFSectParser( myFont, callback ) {}

		virtual plBDFSectParser *ParseKeyword( const char *keyword, plLineParser &line )
		{
			if( strcmp( keyword, "CHARS" ) == 0 )
			{
				// Horray!
				return TRACKED_NEW plBDFCharsParser( fFont, fCallback );
			}
			// Just gobble lines until we find the chars section
			return this;
		}
};

class plBDFPropertiesParser : public plBDFSectParser
{
	public:
		plBDFPropertiesParser( plFont &myFont, plBDFConvertCallback *callback ) : plBDFSectParser( myFont, callback ) {}

		virtual plBDFSectParser *ParseKeyword( const char *keyword, plLineParser &line )
		{
			// Note: the properties section is entirely optional and arbitrary, but we
			// parse it in case we can get more accurate info about the font name and props
			if( strcmp( keyword, "FACE_NAME" ) == 0 )
			{
				fFont.SetFace( line.GetString() );
			}
			else if( strcmp( keyword, "WEIGHT_NAME" ) == 0 )
			{
				if( stricmp( line.GetString(), "Bold" ) == 0 )
					fFont.SetFlag( plFont::kFlagBold, true );
			}
			else if( strcmp( keyword, "ENDPROPERTIES" ) == 0 )
			{
				// Switch to waiting for the chars section
				return TRACKED_NEW plBDFLookForCharParser( fFont, fCallback );
			}
			// All tokens are technically valid, even if we don't recognize them
			return this;
		}
};

class plBDFHeaderParser : public plBDFSectParser
{
	public:
		plBDFHeaderParser( plFont &myFont, plBDFConvertCallback *callback ) : plBDFSectParser( myFont, callback ) {}

		virtual plBDFSectParser *ParseKeyword( const char *keyword, plLineParser &line )
		{
			if( strcmp( keyword, "STARTFONT" ) == 0 )
			{
				// Start of the font; check version #
				float version = line.GetFloat();
				if( version < 2.1f )
					throw false;

				// Initial font values
				fFont.fFirstChar = 0;
				fFont.fMaxCharHeight = 0;
			}
			else if( strcmp( keyword, "FONT" ) == 0 )
			{
				// Postscript-style font name: figure out our face name and hopefully attributes too
				// Format is usually of the form: vendor-face-weight-otherStuff
				const char *vendor = line.GetKeywordNoDashes();
				const char *face = line.GetKeywordNoDashes();

				fFont.SetFace( face != nil ? face : vendor );

				const char *weight = line.GetKeywordNoDashes();

				if( weight != nil && stricmp( weight, "Bold" ) == 0 )
					fFont.SetFlag( plFont::kFlagBold, true );
			}
			else if( strcmp( keyword, "COMMENT" ) == 0 )
			{
				// Comment, ignore
			}
			else if( strcmp( keyword, "CONTENTVERSION" ) == 0 )
			{
				// Content version, app specific, not used by us
			}
			else if( strcmp( keyword, "SIZE" ) == 0 )
			{
				// Point size and target resolution of this font
				fFont.SetSize( (UInt8)(line.GetInt()) );
				plBDFCharsParser::fResolution = line.GetInt();
			}
			else if( strcmp( keyword, "FONTBOUNDINGBOX" ) == 0 )
			{
				// Max dimensions and base offsets
				// Note that we should've already grabbed the width from our
				// prescan earlier, to guard against malformed BDFs
				int thisWidth = line.GetInt();
				if( fFont.fWidth < thisWidth )
					fFont.fWidth = thisWidth;

				// Since we're 1 bbp, make sure width is a multiple of 8
				fFont.fWidth = ( ( fFont.fWidth + 7 ) >> 3 ) << 3;

				// Allocate our data now
				fFont.fBMapData = TRACKED_NEW UInt8[ ( fFont.fWidth * fFont.fHeight * fFont.fBPP ) >> 3 ];
				memset( fFont.fBMapData, 0, ( fFont.fWidth * fFont.fHeight * fFont.fBPP ) >> 3 );

				fFont.fMaxCharHeight = line.GetInt();
			}
			else if( strcmp( keyword, "METRICSSET" ) == 0 )
			{
				// Metrics set specification; unsupported
			}
			else if( strcmp( keyword, "STARTPROPERTIES" ) == 0 )
			{
				// Start of the properties section, switch to that
				return TRACKED_NEW plBDFPropertiesParser( fFont, fCallback );
			}
			else if( strcmp( keyword, "CHARS" ) == 0 )
			{
				// Allocate our bitmap if we haven't already

				// Since we're 1 bbp, make sure width is a multiple of 8
				if( fFont.fBMapData == nil )
				{
					fFont.fWidth = ( ( fFont.fWidth + 7 ) >> 3 ) << 3;

					// Allocate our data now
					fFont.fBMapData = TRACKED_NEW UInt8[ ( fFont.fWidth * fFont.fHeight * fFont.fBPP ) >> 3 ];
					memset( fFont.fBMapData, 0, ( fFont.fWidth * fFont.fHeight * fFont.fBPP ) >> 3 );
				}

				// Start of the char section
				return TRACKED_NEW plBDFCharsParser( fFont, fCallback );
			}
			else
			{
				// Unrecognized token, abort
				throw false;
			}

			// Default, keep going with our parser
			return this;
		}
};

class plBDFCheckDimsParser : public plBDFSectParser
{
		hsBool	fSkipNext;

	public:

		UInt32	fMaxWidth, fMaxHeight, fNumChars, fTotalHeight;
		UInt16	fMaxChar;

		plBDFCheckDimsParser( plFont &myFont ) : plBDFSectParser( myFont, nil ) { fMaxWidth = fMaxHeight = fNumChars = fTotalHeight = 0; fSkipNext = false; fMaxChar = 0; }

		virtual plBDFSectParser *ParseKeyword( const char *keyword, plLineParser &line )
		{
			if( strcmp( keyword, "ENDFONT" ) == 0 )
			{
				// All done!
				return nil;
			}
			// Encoding
			else if( strcmp( keyword, "ENCODING" ) == 0 )
			{
				int ch = line.GetInt();
				if( ch == -1 )
					// We skip these
					fSkipNext = true;
				else
				{
					fSkipNext = false;
					if( fMaxChar < ch )
						fMaxChar = ch;
				}
			}
			// Bitmap bounding box
			else if( strcmp( keyword, "BBX" ) == 0 )
			{
				if( fSkipNext )
					return this;

				int pixW = line.GetInt();
				int pixH = line.GetInt();
				int xOff = line.GetInt();
				int yOff = line.GetInt();

				if( fMaxWidth < pixW )
					fMaxWidth = pixW;
				if( fMaxHeight < pixH )
					fMaxHeight = pixH;

				fNumChars++;

				fTotalHeight += pixH;
			}
			return this;
		}
};

hsBool	plFont::LoadFromBDFStream( hsStream *stream, plBDFConvertCallback *callback )
{
	return false;
}

hsBool	plFont::LoadFromBDF( const char *path, plBDFConvertCallback *callback )
{
	FILE *fp = fopen( path, "rt" );
	if( fp == nil )
		return false;
	try
	{
		IClear();

		char	line[ 512 ];

		// Run through the entire file first with a plBDFCheckDimsParser. This is because
		// some BDFs are naughty and don't report the correct fontboundingbox (i.e. too small)
		// (See the following loop below for details on the workings of this loop)
		plBDFCheckDimsParser	checkDims( *this );
		while( fgets( line, sizeof( line ), fp ) )
		{
			plLineParser	parser( line );
			const char *keyword = parser.GetKeyword();
			if( keyword != nil )
			{
				if( checkDims.ParseKeyword( keyword, parser ) == nil )
					break;
			}
		}

		// Set up initial values
		fWidth = checkDims.fMaxWidth;
		fHeight = checkDims.fTotalHeight;
		fBPP = 1;

		// Pre-expand our char list
		fCharacters.ExpandAndZero( checkDims.fMaxChar + 1 );
		fCharacters.SetCount( 0 );

		if( callback != nil )
			callback->NumChars( (UInt16)(checkDims.fNumChars) );

		// Rewind and continue normally
		fseek( fp, 0, SEEK_SET );

		// Start with the header parser
		plBDFSectParser *currParser = TRACKED_NEW plBDFHeaderParser( *this, callback );

		// Read from the stream one line at a time (don't want comments, and char #1 should be invalid for a BDF)
		while( fgets( line, sizeof( line ), fp ) && currParser != nil )
		{
			// Parse this one
			plLineParser	parser( line );

			// Get the keyword for this line
			const char *keyword = parser.GetKeyword();
			if( keyword != nil )
			{
				// Pass on to the current parser
				plBDFSectParser *newParser = currParser->ParseKeyword( keyword, parser );
				if( newParser != currParser )
				{
					delete currParser;
					currParser = newParser;
				}
			}
		}
	}
	catch( ... )
	{
		IClear();
		return false;
	}

	fclose( fp );

	ICalcFontAscent();
	return true;
}

hsBool	plFont::ReadRaw( hsStream *s )
{
	s->Read( sizeof( fFace ), fFace );
	fSize = s->ReadByte();
	s->ReadSwap( &fFlags );

	s->ReadSwap( &fWidth );
	s->ReadSwap( &fHeight );
	s->ReadSwap( &fMaxCharHeight );

	fBPP = s->ReadByte();

	UInt32 size = ( fWidth * fHeight * fBPP ) >> 3;
	if( size > 0 )
	{
		fBMapData = TRACKED_NEW UInt8[ size ];
		s->Read( size, fBMapData );
	}
	else
		fBMapData = nil;

	s->ReadSwap( &fFirstChar );

	UInt32 i;
	fCharacters.SetCountAndZero( s->ReadSwap32() );
	for( i = 0; i < fCharacters.GetCount(); i++ )
		fCharacters[ i ].Read( s );

	ICalcFontAscent();

	return true;
}

hsBool	plFont::WriteRaw( hsStream *s )
{
	s->Write( sizeof( fFace ), fFace );
	s->WriteByte( fSize );
	s->WriteSwap( fFlags );

	s->WriteSwap( fWidth );
	s->WriteSwap( fHeight );
	s->WriteSwap( fMaxCharHeight );

	s->WriteByte( fBPP );

	UInt32 size = ( fWidth * fHeight * fBPP ) >> 3;
	if( size > 0 )
		s->Write( size, fBMapData );

	s->WriteSwap( fFirstChar );

	UInt32 i;
	s->WriteSwap32( fCharacters.GetCount() );
	for( i = 0; i < fCharacters.GetCount(); i++ )
		fCharacters[ i ].Write( s );

	return true;
}
