#ifndef __LP64__

#include <vector>
#include <iostream>
#include <string>
#include "tmathutil.h"
#include "tdebugmessage.h"
#include "tfont.h"
#include "tstroke.h"
#include "tcurves.h"
#include "tconvert.h"
#include "tvectorimage.h"

using namespace std;

//----------------------------------------- structures -------------------------------------------------------------------

typedef struct {
	Float32Point origin;  // The origin of the current glyph
	Boolean first;		  // Keeps track of which segment is first in a glyph
	Float32Point current; // The current pen position (used to filter degenerate cases)

	float adv;
	TVectorImageP m_image;
	std::vector<TThickPoint> m_points;

} MyCurveCallbackData;

typedef struct {
	ATSGlyphRef glyphID;		 // The glyphID.  This is simply an index into a table in the font.
	Float32Point relativeOrigin; // The origin of this glyph -- relative to the origin of the line.
} MyGlyphRecord;

//----------------------------------------- callback---------------------------------------------------------------------

OSStatus MyQuadraticLineProc(const Float32Point *pt1, const Float32Point *pt2, void *callBackDataPtr)
{
	/*
    // Adjust the points according to the glyph origin
    float x1 = ((MyCurveCallbackData *)callBackDataPtr)->origin.x + pt1->x;
    float y1 = ((MyCurveCallbackData *)callBackDataPtr)->origin.y + pt1->y;
    float x2 = ((MyCurveCallbackData *)callBackDataPtr)->origin.x + pt2->x;
    float y2 = ((MyCurveCallbackData *)callBackDataPtr)->origin.y + pt2->y;
    */

	MyCurveCallbackData *data = (MyCurveCallbackData *)callBackDataPtr;

	if (data->m_points.empty())
		data->m_points.push_back(TThickPoint(pt1->x, pt1->y, 0));
	//else
	//assert(isAlmostEqual(pt1 e back)

	TThickPoint lastPoint = TThickPoint(pt2->x, pt2->y, 0);
	data->m_points.push_back((data->m_points.back() + lastPoint) * 0.5);
	data->m_points.push_back(lastPoint);

	return noErr;
}

OSStatus MyQuadraticCurveProc(const Float32Point *pt1, const Float32Point *controlPt, const Float32Point *pt2, void *callBackDataPtr)
{
	/*
    // Adjust the points according to the glyph origin    
    float x1 = ((MyCurveCallbackData *)callBackDataPtr)->origin.x + pt1->x;
    float y1 = ((MyCurveCallbackData *)callBackDataPtr)->origin.y + pt1->y;
    float x2 = ((MyCurveCallbackData *)callBackDataPtr)->origin.x + pt2->x;
    float y2 = ((MyCurveCallbackData *)callBackDataPtr)->origin.y + pt2->y;
    float cpx = ((MyCurveCallbackData *)callBackDataPtr)->origin.x + controlPt->x;
    float cpy = ((MyCurveCallbackData *)callBackDataPtr)->origin.y + controlPt->y;    
    */
	MyCurveCallbackData *data = (MyCurveCallbackData *)callBackDataPtr;

	if (data->m_points.empty())
		data->m_points.push_back(TThickPoint(pt1->x, pt1->y, 0));
	//else
	//assert(isAlmostEqual(pt1 e back)

	data->m_points.push_back(TThickPoint(controlPt->x, controlPt->y, 0));
	data->m_points.push_back(TThickPoint(pt2->x, pt2->y, 0));

	return noErr;
}

OSStatus MyQuadraticNewPathProc(void *callBackDataPtr)
{
	assert(((MyCurveCallbackData *)callBackDataPtr)->m_points.empty());
	return noErr;
}

OSStatus MyQuadraticClosePathProc(void *callBackDataPtr)
{
	MyCurveCallbackData *data = (MyCurveCallbackData *)callBackDataPtr;

	assert(data->m_points.size() >= 3 && data->m_points.size() & 1); //il numero di punti di controllo devono essere dispari e >= 3

	TStroke *stroke = new TStroke(data->m_points);
	stroke->setSelfLoop(true);

	data->m_points.clear();
	data->m_image->addStroke(stroke);

	return noErr;
}

//------------------------------------------------------------------------------------------------------------------

void GetGlyphIDsAndPositions(ATSUTextLayout iLayout, UniCharArrayOffset iStart, UniCharCount iLength, MyGlyphRecord **oGlyphRecordArray, ItemCount *oNumGlyphs)
{
	// This block of code uses the new Direct Access APIs, which are only available on Mac OS X 10.2 and later systems
	//

	ATSLayoutRecord *layoutRecords;
	ItemCount numRecords;
	Fixed *deltaYs;
	ItemCount numDeltaYs;
	unsigned int i;
	OSStatus status;

	// Get the arrays of glyph information
	status = ATSUDirectGetLayoutDataArrayPtrFromTextLayout(
		iLayout, iStart,
		kATSUDirectDataLayoutRecordATSLayoutRecordCurrent,
		(void **)&layoutRecords, &numRecords);
	assert(status == noErr);

	status = ATSUDirectGetLayoutDataArrayPtrFromTextLayout(
		iLayout, iStart,
		kATSUDirectDataBaselineDeltaFixedArray,
		(void **)&deltaYs, &numDeltaYs);
	assert(status == noErr);

	// Build the array of MyGlyphRecords
	*oGlyphRecordArray = (MyGlyphRecord *)malloc(numRecords * sizeof(MyGlyphRecord));
	*oNumGlyphs = numRecords;

	for (i = 0; i < *oNumGlyphs; i++) {
		// Fill in the glyphID
		(*oGlyphRecordArray)[i].glyphID = layoutRecords[i].glyphID;

		// Set up the relative origin of the glyph
		//
		// The real position is the x coordinate of the glyph, relative to the beginning of the line
		// The baseline delta (deltaY), if any, is the y coordinate of the glyph, relative to the baseline
		//
		(*oGlyphRecordArray)[i].relativeOrigin.x = Fix2X(layoutRecords[i].realPos);

		if (deltaYs == NULL) {
			(*oGlyphRecordArray)[i].relativeOrigin.y = 0.0;
		} else {
			(*oGlyphRecordArray)[i].relativeOrigin.y = 0.0 - Fix2X(deltaYs[i]);
		}
	}

	// Free the arrays of glyph information
	if (deltaYs != NULL) {
		status = ATSUDirectReleaseLayoutDataArrayPtr(NULL, kATSUDirectDataBaselineDeltaFixedArray, (void **)&deltaYs);
		assert(status == noErr);
	}
	status = ATSUDirectReleaseLayoutDataArrayPtr(NULL, kATSUDirectDataLayoutRecordATSLayoutRecordCurrent, (void **)&layoutRecords);
	assert(status == noErr);
}

void drawQuadratics(ATSUTextLayout iLayout, ATSUStyle iStyle, UniCharArrayOffset start, UniCharCount length, MyCurveCallbackData &data)
{
	//boh ----------------
	Fixed penX = 0;
	Fixed penY = 0;
	// -------------------

	MyGlyphRecord *glyphRecordArray;
	ItemCount numGlyphs;
	ATSQuadraticNewPathUPP newPathProc;
	ATSQuadraticLineUPP lineProc;
	ATSQuadraticCurveUPP curveProc;
	ATSQuadraticClosePathUPP closePathProc;

	OSStatus status;
	unsigned int i;

	// Create the Quadratic callbacks
	newPathProc = NewATSQuadraticNewPathUPP(MyQuadraticNewPathProc);
	lineProc = NewATSQuadraticLineUPP(MyQuadraticLineProc);
	curveProc = NewATSQuadraticCurveUPP(MyQuadraticCurveProc);
	closePathProc = NewATSQuadraticClosePathUPP(MyQuadraticClosePathProc);

	// Get the array of glyph information
	GetGlyphIDsAndPositions(iLayout, start, length, &glyphRecordArray, &numGlyphs);

	// Loop over all the glyphs
	for (i = 0; i < numGlyphs; i++) {

		// Set up the absolute origin of the glyph
		data.origin.x = Fix2X(penX) + glyphRecordArray[i].relativeOrigin.x;
		data.origin.y = Fix2X(penY) + glyphRecordArray[i].relativeOrigin.y;

		// Reset state for quadratic drawing (the callbacks only do a MoveTo on the very first segment)
		data.first = true;

		// If this is a deleted glyph (-1), don't draw it.  Otherwise, go ahead.
		if (glyphRecordArray[i].glyphID != kATSDeletedGlyphcode) {
			status = ATSUGlyphGetQuadraticPaths(iStyle, glyphRecordArray[i].glyphID, newPathProc, lineProc, curveProc, closePathProc, &data, &status);
			assert(status == noErr);
		}
	}
	// Free the array of glyph information
	free(glyphRecordArray);

	// Dispose of the Quadratic callbacks

	DisposeATSQuadraticNewPathUPP(newPathProc);
	DisposeATSQuadraticLineUPP(lineProc);
	DisposeATSQuadraticCurveUPP(curveProc);
	DisposeATSQuadraticClosePathUPP(closePathProc);
}

//=============================================================================

struct TFont::Impl {
	bool m_hasKerning;
	int m_hasVertical;

	//  KerningPairs m_kerningPairs;

	ATSUStyle m_style;
	ATSUFontID m_fontId;
	ATSUTextLayout m_layout;
	Fixed m_size;
	int m_ascender;
	int m_descender;

	Impl(ATSUFontID fontId, int size);
	~Impl();

	//void getChar();
};

//-----------------------------------------------------------------------------

TFont::TFont(ATSUFontID fontId, int size)
{
	m_pimpl = new Impl(fontId, size);
}

//-----------------------------------------------------------------------------

TFont::~TFont()
{
	delete m_pimpl;
}

//-----------------------------------------------------------------------------

TFont::Impl::Impl(ATSUFontID fontId, int size)
	: m_fontId(fontId), m_size(Long2Fix(size))
{
	OSStatus status;

	long response;
	status = Gestalt(gestaltATSUFeatures, &response);
	assert(response & gestaltATSUDirectAccess);

	status = ATSUCreateStyle(&m_style);
	assert(status == noErr);

	ATSUAttributeTag tags[2];
	ByteCount sizes[2];
	ATSUAttributeValuePtr values[2];

	tags[0] = kATSUFontTag;
	sizes[0] = sizeof(ATSUFontID);
	values[0] = &fontId;

	tags[1] = kATSUSizeTag;
	sizes[1] = sizeof(Fixed);
	values[1] = &m_size;

	status = ATSUSetAttributes(m_style, 2, tags, sizes, values);
	//assert(status==noErr);

	UniChar dummyStr[] = {'H', 'e', 'l', 'l', 'o'};
	UniCharCount length = sizeof(dummyStr) / sizeof(UniChar);

	status = ATSUCreateTextLayoutWithTextPtr(
		dummyStr, kATSUFromTextBeginning, kATSUToTextEnd, length, 1,
		&length, &m_style, &m_layout);
	//assert(status==noErr);

	ATSTrapezoid glyphBounds;
	status = ATSUGetGlyphBounds(m_layout, 0, 0,
								kATSUFromTextBeginning, kATSUToTextEnd, kATSUseFractionalOrigins,
								1, &glyphBounds, NULL);

	m_ascender = -FixedToInt(glyphBounds.upperLeft.y);
	assert(m_ascender > 0);
	m_descender = -FixedToInt(glyphBounds.lowerLeft.y);
	assert(m_descender < 0);
}

//-----------------------------------------------------------------------------

TFont::Impl::~Impl()
{
}

//-----------------------------------------------------------------------------

TPoint TFont::drawChar(TVectorImageP &image, wchar_t charcode, wchar_t nextCharCode) const
{
	OSStatus status;

	UniChar subString[2];
	subString[0] = charcode;
	subString[1] = 0 /*nextCharCode*/;
	UniCharCount length = sizeof(subString) / sizeof(UniChar);

	status = ATSUCreateTextLayoutWithTextPtr(subString, kATSUFromTextBeginning, kATSUToTextEnd,
											 length, 1,
											 &length, &(m_pimpl->m_style), &(m_pimpl->m_layout));
	assert(status == noErr);

	MyCurveCallbackData data;
	data.m_image = image;

	drawQuadratics(m_pimpl->m_layout, m_pimpl->m_style, kATSUFromTextBeginning, kATSUToTextEnd, data);
	image->transform(TScale(1, -1));

	image->group(0, image->getStrokeCount());

	return getDistance(charcode, nextCharCode);
}

//-----------------------------------------------------------------------------
namespace
{

void appDrawChar(TRasterGR8P &outImage, TFont::Impl *pimpl, wchar_t charcode)
{
	OSStatus status;
	UniChar subString[2];
	subString[0] = charcode;
	subString[1] = 0;
	UniCharCount length = sizeof(subString) / sizeof(UniChar);

	status = ATSUCreateTextLayoutWithTextPtr(subString, kATSUFromTextBeginning, kATSUToTextEnd,
											 length, 1,
											 &length, &(pimpl->m_style), &(pimpl->m_layout));
	assert(status == noErr);

	ATSTrapezoid glyphBounds;
	status = ATSUGetGlyphBounds(pimpl->m_layout, 0, 0,
								kATSUFromTextBeginning, kATSUToTextEnd, kATSUseFractionalOrigins,
								1, &glyphBounds, NULL);

	int height = FixedToInt(glyphBounds.lowerLeft.y) - FixedToInt(glyphBounds.upperLeft.y);
	int width = tmax(FixedToInt(glyphBounds.lowerRight.x), FixedToInt(glyphBounds.upperRight.x)) -
				tmin(FixedToInt(glyphBounds.lowerLeft.x), FixedToInt(glyphBounds.upperLeft.x));

	outImage = TRasterGR8P(width, height);
	TPixelGR8 bgp;
	bgp.value = 255;
	outImage->fill(bgp);
	void *data = outImage->getRawData();

	CGColorSpaceRef grayColorSpace = CGColorSpaceCreateWithName(kCGColorSpaceGenericGray);
	CGContextRef gContext = CGBitmapContextCreate(data, width, height, 8, width, grayColorSpace, kCGImageAlphaNone);

#if defined(DEBUG) || defined(_DEBUG)

	int bpc = CGBitmapContextGetBitsPerComponent(gContext);
	if (bpc != 8)
		std::cout << "BitsPerComponent: " << bpc << std::endl;

	int bpp = CGBitmapContextGetBitsPerPixel(gContext);
	if (bpp != 8)
		std::cout << "BitsPerPixel: " << bpp << std::endl;

	int bytesPerRow = CGBitmapContextGetBytesPerRow(gContext);
	int newWidth = CGBitmapContextGetWidth(gContext);
	if (bytesPerRow != width || newWidth != width)
		std::cout << "BytesPerRow: " << bytesPerRow
				  << " Old width= " << width
				  << " New width= " << newWidth << std::endl;

	int newHeight = CGBitmapContextGetHeight(gContext);
	if (newHeight != height)
		std::cout << " Old height= " << height << " New height= " << newHeight << std::endl;

	assert(CGBitmapContextGetColorSpace(gContext) == grayColorSpace);

#endif

	ATSUAttributeTag tags[1];
	ByteCount sizes[1];
	ATSUAttributeValuePtr values[1];

	tags[0] = kATSUCGContextTag;
	sizes[0] = sizeof(CGContextRef);
	values[0] = &gContext;
	status = ATSUSetLayoutControls(pimpl->m_layout, 1, tags, sizes, values);
	assert(status == noErr);

	ATSUDrawText(pimpl->m_layout, kATSUFromTextBeginning, kATSUToTextEnd, 0, glyphBounds.lowerLeft.y);
}
}
//-----------------------------------------------------------------------------

TPoint TFont::drawChar(TRasterGR8P &outImage, TPoint &unused, wchar_t charcode, wchar_t nextCharCode) const
{
	appDrawChar(outImage, m_pimpl, charcode);
	outImage->yMirror();
	return getDistance(charcode, nextCharCode);
}

//-----------------------------------------------------------------------------

TPoint TFont::drawChar(TRasterCM32P &outImage, TPoint &unused, int inkId, wchar_t charcode, wchar_t nextCharCode) const
{
	TRasterGR8P grayAppImage;
	appDrawChar(grayAppImage, m_pimpl, charcode);

	int lx = grayAppImage->getLx();
	int ly = grayAppImage->getLy();

	outImage = TRasterCM32P(lx, ly);

	assert(TPixelCM32::getMaxTone() == 255);
	TPixelCM32 bgColor(0, 0, TPixelCM32::getMaxTone());
	grayAppImage->lock();
	outImage->lock();
	int ty = 0;
	for (int gy = ly - 1; gy >= 0; --gy, ++ty) {
		TPixelGR8 *srcPix = grayAppImage->pixels(gy);
		TPixelCM32 *tarPix = outImage->pixels(ty);
		for (int x = 0; x < lx; ++x) {
			int tone = srcPix->value;

			if (tone == 255)
				*tarPix = bgColor;
			else
				*tarPix = TPixelCM32(inkId, 0, tone);

			++srcPix;
			++tarPix;
		}
	}
	grayAppImage->unlock();
	outImage->unlock();

	return getDistance(charcode, nextCharCode);
}

//-----------------------------------------------------------------------------

TPoint TFont::getDistance(wchar_t firstChar, wchar_t secondChar) const
{
	OSStatus status;
	UniChar subString[2];
	subString[0] = firstChar;
	subString[1] = secondChar;
	UniCharCount length = sizeof(subString) / sizeof(UniChar);

	status = ATSUCreateTextLayoutWithTextPtr(subString, kATSUFromTextBeginning, kATSUToTextEnd,
											 length, 1,
											 &length, &(m_pimpl->m_style), &(m_pimpl->m_layout));
	assert(status == noErr);

	MyGlyphRecord *glyphRecordArray;
	ItemCount numGlyphs;

	// Get the array of glyph information
	GetGlyphIDsAndPositions(m_pimpl->m_layout, kATSUFromTextBeginning, kATSUToTextEnd, &glyphRecordArray, &numGlyphs);

	assert(numGlyphs >= 2);

	assert(glyphRecordArray[0].relativeOrigin.x == 0);
	int advance = (int)(glyphRecordArray[1].relativeOrigin.x - glyphRecordArray[0].relativeOrigin.x);
	if (advance == 0) {
		subString[1] = 0;
		status = ATSUCreateTextLayoutWithTextPtr(subString, kATSUFromTextBeginning, kATSUToTextEnd,
												 length, 1,
												 &length, &(m_pimpl->m_style), &(m_pimpl->m_layout));

		GetGlyphIDsAndPositions(m_pimpl->m_layout, kATSUFromTextBeginning, kATSUToTextEnd, &glyphRecordArray, &numGlyphs);
		advance = (int)(glyphRecordArray[1].relativeOrigin.x - glyphRecordArray[0].relativeOrigin.x);
	}
	return TPoint(advance, 0);
}

//-----------------------------------------------------------------------------

int TFont::getMaxHeight() const
{
	return m_pimpl->m_ascender - m_pimpl->m_descender;
}

//-----------------------------------------------------------------------------

int TFont::getMaxWidth() const
{
	assert(!"not implemented yet");
	return 100;
}
//-----------------------------------------------------------------------------

int TFont::getLineAscender() const
{
	return m_pimpl->m_ascender;
}

//-----------------------------------------------------------------------------

int TFont::getLineDescender() const
{
	return m_pimpl->m_descender;
}

//-----------------------------------------------------------------------------

bool TFont::hasKerning() const
{
	return true;
}

//-----------------------------------------------------------------------------

bool TFont::hasVertical() const
{
	return false;
}

//-----------------------------------------------------------------------------

#include <string>
#include <map>

typedef std::map<std::string, ATSUFontID> FontFamily;

typedef std::map<std::string, FontFamily> FamilyMap;

struct TFontManager::Impl {
	FamilyMap m_families;
	bool m_loaded;
	ATSUFontID m_currentAtsuFontId;
	TFont *m_currentFont;
	wstring m_currentFamily;
	wstring m_currentTypeface;
	int m_size;

	Impl()
		: m_currentAtsuFontId(0), m_currentFont(0), m_loaded(false), m_size(70)
	{
	}

	bool setFontName(ATSUFontID fontId, int platform, int script, int lang);
	bool addFont(ATSUFontID);
	void loadFontNames();
	bool setFont(std::wstring family, std::wstring style);
};

using namespace std;

bool TFontManager::Impl::setFontName(ATSUFontID fontId, int platform, int script, int lang)
{
	ByteCount oActualNameLength;
	ItemCount oFontCount;
	OSStatus status;

	char *buffer = 0;
	char *buffer2 = 0;

	// chiedo la lunhezza del Full Family Name per allocare il buffer
	status = ATSUFindFontName(fontId,
							  kFontFullName,
							  platform,
							  script,
							  lang,
							  0, 0,
							  &oActualNameLength,
							  0);

	if (status != noErr || oActualNameLength <= 1)
		return false;

	buffer = new char[oActualNameLength + 1];
	// chiedo il Full Family Name
	status = ATSUFindFontName(fontId,
							  kFontFullName,
							  platform,
							  script,
							  lang,
							  oActualNameLength, buffer,
							  &oActualNameLength,
							  &oFontCount);

	if (status != noErr || oActualNameLength <= 1 || buffer[0] == '\0') {
		delete[] buffer;
		return false;
	}
	buffer[oActualNameLength] = '\0';

	//-------------------

	// chiedo la lunhezza del Typeface Name per allocare il buffer
	status = ATSUFindFontName(fontId,
							  kFontStyleName,
							  platform,
							  script,
							  lang,
							  0, 0,
							  &oActualNameLength,
							  0);

	if (status != noErr || oActualNameLength <= 1) {
		delete[] buffer;
		return false;
	}
	buffer2 = new char[oActualNameLength + 1];

	// chiedo il Typeface Name
	status = ATSUFindFontName(fontId,
							  kFontStyleName,
							  platform,
							  script,
							  lang,
							  oActualNameLength, buffer2,
							  &oActualNameLength,
							  &oFontCount);

	if (status != noErr || oActualNameLength <= 1 || buffer2[0] == '\0') {
		delete[] buffer;
		delete[] buffer2;
		return false;
	} else
		buffer2[oActualNameLength] = '\0';

	string s_family(buffer);
	FontFamily &family = m_families[s_family];
	family[string(buffer2)] = fontId;
	delete[] buffer;
	delete[] buffer2;
	return true;
}

bool TFontManager::Impl::addFont(ATSUFontID fontId)
{
	int platform, script, lang;

	// per ottimizzare, ciclo solo sui valori
	// piu' comuni
	for (lang = -1; lang <= 0; lang++)
		for (platform = -1; platform <= 1; platform++)
			for (script = -1; script <= 0; script++)
				if (setFontName(fontId, platform, script, lang))
					return true;

	//poi li provo tutti
	for (lang = -1; lang <= 139; lang++)
		for (script = -1; script <= 32; script++)
			for (platform = -1; platform <= 4; platform++) {
				// escludo quelli nel tri-ciclo for precedente.
				// Purtoppo si deve fare cosi:
				// non si puo' fare partendo con indici piu' alti nei cicli for!
				if (-1 <= lang && lang <= 0 &&
					-1 <= script && script <= 0 &&
					-1 <= platform && platform <= 1)
					continue;

				if (setFontName(fontId, platform, script, lang))
					return true;
			}

	return false;
}

void TFontManager::Impl::loadFontNames()
{
	if (m_loaded)
		return;

	ItemCount oFontCount, fontCount;
	ATSUFontCount(&oFontCount);
	fontCount = oFontCount;
	ATSUFontID *oFontIDs = new ATSUFontID[fontCount];
	ATSUGetFontIDs(oFontIDs, fontCount, &oFontCount);
	assert(fontCount == oFontCount);

	for (unsigned int i = 0; i < fontCount; i++)
		addFont(oFontIDs[i]);

	delete[] oFontIDs;
	m_loaded = true;
}

bool TFontManager::Impl::setFont(std::wstring family, std::wstring typeface)
{
	if (family == m_currentFamily && (typeface == m_currentTypeface || typeface == L""))
		return false;

	FamilyMap::iterator family_it = m_families.find(toString(family));
	if (family_it == m_families.end())
		throw TFontCreationError();

	m_currentFamily = family;
	FontFamily::iterator style_it;
	if (typeface == L"") {
		style_it = ((*family_it).second).find(toString(m_currentTypeface));
		if (style_it == (*family_it).second.end())
			style_it = ((*family_it).second).begin();

		typeface = toWideString(style_it->first);
	} else
		style_it = ((*family_it).second).find(toString(typeface));

	if (style_it == (*family_it).second.end())
		throw TFontCreationError();

	m_currentTypeface = typeface;
	m_currentAtsuFontId = (*style_it).second;
	return true;
}

//---------------------------------------------------------

TFontManager::TFontManager()
{
	m_pimpl = new TFontManager::Impl();
}

//---------------------------------------------------------

TFontManager::~TFontManager()
{
	delete m_pimpl;
}

//---------------------------------------------------------

TFontManager *TFontManager::instance()
{
	static TFontManager theManager;
	return &theManager;
}

//---------------------------------------------------------

void TFontManager::loadFontNames()
{
	m_pimpl->loadFontNames();
}

//---------------------------------------------------------

void TFontManager::setFamily(const wstring family)
{
	bool changed = m_pimpl->setFont(family, L"");
	if (changed) {
		delete m_pimpl->m_currentFont;
		m_pimpl->m_currentFont = new TFont(m_pimpl->m_currentAtsuFontId, m_pimpl->m_size);
	}
}

//---------------------------------------------------------

void TFontManager::setTypeface(const wstring typeface)
{
	bool changed = m_pimpl->setFont(m_pimpl->m_currentFamily, typeface);
	if (changed) {
		delete m_pimpl->m_currentFont;
		m_pimpl->m_currentFont = new TFont(m_pimpl->m_currentAtsuFontId, m_pimpl->m_size);
	}
}

//---------------------------------------------------------

void TFontManager::setSize(int size)
{
	if (m_pimpl->m_size != size) {
		m_pimpl->m_size = size;
		delete m_pimpl->m_currentFont;
		m_pimpl->m_currentFont = new TFont(m_pimpl->m_currentAtsuFontId, m_pimpl->m_size);
	}
}

//---------------------------------------------------------

wstring TFontManager::getCurrentFamily() const
{
	return m_pimpl->m_currentFamily;
}

//---------------------------------------------------------

wstring TFontManager::getCurrentTypeface() const
{
	return m_pimpl->m_currentTypeface;
}

//---------------------------------------------------------

TFont *TFontManager::getCurrentFont()
{
	if (m_pimpl->m_currentFont)
		return m_pimpl->m_currentFont;

	if (!m_pimpl->m_currentFont)
		loadFontNames();

	assert(!m_pimpl->m_families.empty());
	setFamily(toWideString(m_pimpl->m_families.begin()->first));

	return m_pimpl->m_currentFont;
}

//---------------------------------------------------------

void TFontManager::getAllFamilies(vector<wstring> &families) const
{
	families.clear();
	families.reserve(m_pimpl->m_families.size());

	FamilyMap::iterator it = m_pimpl->m_families.begin();
	for (; it != m_pimpl->m_families.end(); ++it) {
		families.push_back(toWideString(it->first));
	}
}

//---------------------------------------------------------

void TFontManager::getAllTypefaces(vector<wstring> &typefaces) const
{
	typefaces.clear();
	FamilyMap::iterator it_family = m_pimpl->m_families.find(toString(m_pimpl->m_currentFamily));
	if (it_family == m_pimpl->m_families.end())
		return;
	FontFamily &typefaceSet = it_family->second;

	typefaces.reserve(typefaceSet.size());
	FontFamily::iterator it_typeface = typefaceSet.begin();
	for (; it_typeface != typefaceSet.end(); ++it_typeface) {
		typefaces.push_back(toWideString(it_typeface->first));
	}
}

//---------------------------------------------------------

void TFontManager::setVertical(bool vertical) {}

//---------------------------------------------------------

#endif