#ifndef __LP64__

#include <vector></vector>

#include <iostream></iostream>

#include <string></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;</tthickpoint>

} 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></string>

#include <map></map>

typedef std::map<std::string, atsufontid=""> FontFamily;</std::string,>

typedef std::map<std::string, fontfamily=""> FamilyMap;</std::string,>

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 {</wstring>

  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 {</wstring>

  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