

#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
