// character_manager.cpp: implementation of the TFont class.
//
//////////////////////////////////////////////////////////////////////
#include "tpixelgr.h"
#include "tfont.h"
#include "tstroke.h"
//#include "tcurves.h"
#include "traster.h"
#include <vector>
#include <iostream>
#include <string>
//#include <tstring.h>
#include <tmathutil.h>
//#include <tdebugmessage.h>
#include "tvectorimage.h"
using namespace std;
//=============================================================================
typedef map<wstring, LOGFONTW> WindowsFontTable;
typedef map<pair<unsigned short, unsigned short>, int> KerningPairs;
//=============================================================================
struct TFont::Impl {
bool m_hasKerning;
bool m_hasVertical;
HFONT m_font;
HDC m_hdc;
TEXTMETRICW m_metrics;
KerningPairs m_kerningPairs;
Impl(const LOGFONTW &font, HDC hdc);
~Impl();
};
//-----------------------------------------------------------------------------
TFont::TFont(const LOGFONTW &font, HDC hdc)
{
m_pimpl = new Impl(font, hdc);
}
//-----------------------------------------------------------------------------
TFont::~TFont()
{
delete m_pimpl;
}
//-----------------------------------------------------------------------------
TFont::Impl::Impl(const LOGFONTW &logfont, HDC hdc)
: m_hdc(hdc)
{
m_font = CreateFontIndirectW(&logfont);
if (!m_font)
throw TFontCreationError();
HGDIOBJ hObj = SelectObject(hdc, m_font);
if (!hObj || hObj == HGDI_ERROR)
throw TFontCreationError();
if (!GetTextMetricsW(hdc, &m_metrics))
throw TFontCreationError();
DWORD pairsCount = GetKerningPairsW(hdc, 0, 0);
if (pairsCount) {
m_hasKerning = true;
std::unique_ptr<KERNINGPAIR[]> tempKernPairs(new KERNINGPAIR[pairsCount]);
GetKerningPairsW(hdc, pairsCount, tempKernPairs.get());
for (UINT i = 0; i < pairsCount; i++) {
pair<unsigned short, unsigned short> key = make_pair(tempKernPairs[i].wFirst, tempKernPairs[i].wSecond);
m_kerningPairs[key] = tempKernPairs[i].iKernAmount;
}
} else
m_hasKerning = false;
m_hasVertical = (logfont.lfFaceName)[0] == '@';
}
//-----------------------------------------------------------------------------
TFont::Impl::~Impl()
{
//delete m_advances;
DeleteObject(m_font);
}
//-----------------------------------------------------------------------------
namespace
{
inline TThickPoint toThickPoint(POINTFX point)
{
double app1 = point.x.value + ((double)point.x.fract) / (std::numeric_limits<WORD>::max)();
double app2 = point.y.value + ((double)point.y.fract) / (std::numeric_limits<WORD>::max)();
return TThickPoint(app1, app2, 0);
}
}
//-----------------------------------------------------------------------------
TPoint TFont::drawChar(TVectorImageP &image, wchar_t charcode, wchar_t nextCharCode) const
{
GLYPHMETRICS gm;
MAT2 mat2;
mat2.eM11.fract = 0;
mat2.eM12.fract = 0;
mat2.eM21.fract = 0;
mat2.eM22.fract = 0;
mat2.eM11.value = 1;
mat2.eM12.value = 0;
mat2.eM21.value = 0;
mat2.eM22.value = 1;
vector<TThickPoint> points;
UINT j = 0;
DWORD charMemorySize = GetGlyphOutlineW(m_pimpl->m_hdc, charcode, GGO_NATIVE, &gm, 0, 0, &mat2);
if (charMemorySize == GDI_ERROR) {
assert(0);
return TPoint();
}
std::unique_ptr<char[]> lpvBuffer(new char[charMemorySize]);
charMemorySize = GetGlyphOutlineW(m_pimpl->m_hdc, charcode, GGO_NATIVE, &gm, charMemorySize, lpvBuffer.get(), &mat2);
if (charMemorySize == GDI_ERROR) {
assert(0);
return TPoint();
}
TTPOLYGONHEADER *header = (TTPOLYGONHEADER *)lpvBuffer.get();
while ((char *)header < (char *)lpvBuffer.get() + charMemorySize) {
points.clear();
TThickPoint startPoint = toThickPoint(header->pfxStart);
points.push_back(startPoint);
if (header->dwType != TT_POLYGON_TYPE) {
assert(0);
}
int memorySize = header->cb;
TTPOLYCURVE *curve = (TTPOLYCURVE *)(header + 1);
while ((char *)curve < (char *)header + memorySize) {
switch (curve->wType) {
case TT_PRIM_LINE:
for (j = 0; j < curve->cpfx; j++) {
TThickPoint p0 = points.back();
TThickPoint p1 = toThickPoint(((*curve).apfx[j]));
points.push_back((p0 + p1) * 0.5);
points.push_back(p1);
}
break;
case TT_PRIM_QSPLINE:
for (j = 0; (int)j + 2 < curve->cpfx; j++) {
TThickPoint p1 = toThickPoint(((*curve).apfx[j]));
TThickPoint p2 = toThickPoint(((*curve).apfx[j + 1]));
points.push_back(p1);
points.push_back((p1 + p2) * 0.5);
}
points.push_back(toThickPoint(((*curve).apfx[j++])));
points.push_back(toThickPoint(((*curve).apfx[j++])));
break;
case TT_PRIM_CSPLINE:
assert(0);
break;
default:
assert(0);
}
curve = (TTPOLYCURVE *)(&(curve->apfx)[j]);
}
TThickPoint p0 = points.back();
if (!isAlmostZero(p0.x - startPoint.x) || !isAlmostZero(p0.y - startPoint.y)) {
points.push_back((p0 + startPoint) * 0.5);
points.push_back(startPoint);
}
TStroke *stroke = new TStroke();
stroke->reshape(&(points[0]), points.size());
stroke->setSelfLoop(true);
image->addStroke(stroke);
header = (TTPOLYGONHEADER *)curve;
}
image->group(0, image->getStrokeCount());
return getDistance(charcode, nextCharCode);
}
//-----------------------------------------------------------------------------
namespace
{
TPoint appDrawChar(TRasterGR8P &outImage, HDC hdc, wchar_t charcode)
{
GLYPHMETRICS gm;
MAT2 mat2;
mat2.eM11.fract = 0;
mat2.eM12.fract = 0;
mat2.eM21.fract = 0;
mat2.eM22.fract = 0;
mat2.eM11.value = 1;
mat2.eM12.value = 0;
mat2.eM21.value = 0;
mat2.eM22.value = 1;
DWORD charMemorySize = GetGlyphOutlineW(hdc, charcode, GGO_GRAY8_BITMAP, &gm, 0, 0, &mat2);
if (charMemorySize == GDI_ERROR) {
assert(0);
}
int lx = gm.gmBlackBoxX;
int ly = gm.gmBlackBoxY;
int wrap = ((lx + 3) >> 2) << 2;
TRasterGR8P appImage = TRasterGR8P(wrap, ly);
appImage->clear();
outImage = appImage->extract(0, 0, lx - 1, ly - 1);
outImage->lock();
GetGlyphOutlineW(hdc, charcode, GGO_GRAY8_BITMAP, &gm, wrap * ly, outImage->getRawData(), &mat2);
outImage->unlock();
TPoint glyphOrig;
glyphOrig.x = gm.gmptGlyphOrigin.x;
glyphOrig.y = gm.gmptGlyphOrigin.y;
return glyphOrig;
}
}
//-----------------------------------------------------------------------------
//valori compresi tra 0 e 64 (si si, proprio 64 e non 63: sono 65 valori)
TPoint TFont::drawChar(TRasterGR8P &outImage, TPoint &glyphOrigin, wchar_t charcode, wchar_t nextCharCode) const
{
TRasterGR8P grayAppImage;
TPoint glyphOrig = appDrawChar(grayAppImage, m_pimpl->m_hdc, charcode);
if (glyphOrig.x < 0) {
glyphOrigin.x = glyphOrig.x;
glyphOrig.x = 0;
} else
glyphOrigin.x = 0;
if (glyphOrig.y < 0) {
glyphOrigin.y = glyphOrig.y;
glyphOrig.y = 0;
} else
glyphOrigin.y = 0;
int srcLx = grayAppImage->getLx();
int srcLy = grayAppImage->getLy();
int dstLx = srcLx + glyphOrig.x;
int dstLy = getMaxHeight();
outImage = TRasterGR8P(dstLx, dstLy);
outImage->clear();
int ty = m_pimpl->m_metrics.tmDescent - 1 + glyphOrig.y;
assert(ty < dstLy);
assert(ty >= srcLy - 1);
grayAppImage->lock();
outImage->lock();
for (int sy = 0; sy < srcLy; ++sy, --ty) {
TPixelGR8 *srcPix = grayAppImage->pixels(sy);
TPixelGR8 *tarPix = outImage->pixels(ty) + glyphOrig.x;
for (int x = 0; x < srcLx; ++x) {
assert(srcPix->value < 65);
switch (srcPix->value) {
case 0:
tarPix->value = 0;
DEFAULT:
tarPix->value = (srcPix->value << 2) - 1;
}
++srcPix;
++tarPix;
}
}
grayAppImage->unlock();
outImage->unlock();
return getDistance(charcode, nextCharCode);
}
//-----------------------------------------------------------------------------
TPoint TFont::drawChar(TRasterCM32P &outImage, TPoint &glyphOrigin, int inkId, wchar_t charcode, wchar_t nextCharCode) const
{
TRasterGR8P grayAppImage;
TPoint glyphOrig = appDrawChar(grayAppImage, m_pimpl->m_hdc, charcode);
if (glyphOrig.x < 0) {
glyphOrigin.x = glyphOrig.x;
glyphOrig.x = 0;
} else
glyphOrigin.x = 0;
if (glyphOrig.y < 0) {
glyphOrigin.y = glyphOrig.y;
glyphOrig.y = 0;
} else
glyphOrigin.y = 0;
int srcLx = grayAppImage->getLx();
int srcLy = grayAppImage->getLy();
int dstLx = srcLx + glyphOrig.x;
int dstLy = getMaxHeight();
outImage = TRasterCM32P(dstLx, dstLy);
outImage->clear();
assert(TPixelCM32::getMaxTone() == 255);
// TPixelCM32 bgColor(BackgroundStyle,BackgroundStyle,TPixelCM32::getMaxTone());
TPixelCM32 bgColor;
int ty = m_pimpl->m_metrics.tmDescent - 1 + glyphOrig.y;
assert(ty < dstLy);
assert(ty >= srcLy - 1);
grayAppImage->lock();
outImage->lock();
for (int sy = 0; sy < srcLy; ++sy, --ty) {
TPixelGR8 *srcPix = grayAppImage->pixels(sy);
TPixelCM32 *tarPix = outImage->pixels(ty) + glyphOrig.x;
for (int x = 0; x < srcLx; ++x) {
int tone = 256 - (srcPix->value << 2);
// grayScale ToonzImage tone Meaning
// 0 255 Bg = PurePaint
// 1 252
// ...
// 63 4
// 64 0 Fg = Pure Ink
if (tone < 0)
tone = 0;
if (tone >= 255)
*tarPix = bgColor;
else
*tarPix = TPixelCM32(inkId, 0, tone); // BackgroundStyle,tone);
++srcPix;
++tarPix;
}
}
grayAppImage->unlock();
outImage->unlock();
return getDistance(charcode, nextCharCode);
}
//-----------------------------------------------------------------------------
TPoint TFont::getDistance(wchar_t firstChar, wchar_t secondChar) const
{
int advance;
BOOL result = GetCharWidth32W(m_pimpl->m_hdc, firstChar, firstChar, &advance);
assert(result);
if (m_pimpl->m_hasKerning && secondChar) {
KerningPairs::iterator it = m_pimpl->m_kerningPairs.find(make_pair(firstChar, secondChar));
if (it != m_pimpl->m_kerningPairs.end()) {
advance += it->second;
}
}
return TPoint(advance, 0);
}
//-----------------------------------------------------------------------------
int TFont::getMaxHeight() const
{
return m_pimpl->m_metrics.tmHeight;
}
//-----------------------------------------------------------------------------
int TFont::getMaxWidth() const
{
return m_pimpl->m_metrics.tmMaxCharWidth;
}
//-----------------------------------------------------------------------------
int TFont::getLineAscender() const
{
return m_pimpl->m_metrics.tmAscent;
}
//-----------------------------------------------------------------------------
int TFont::getLineDescender() const
{
return -m_pimpl->m_metrics.tmDescent;
}
//-----------------------------------------------------------------------------
bool TFont::hasKerning() const
{
return m_pimpl->m_hasKerning;
}
//-----------------------------------------------------------------------------
bool TFont::hasVertical() const
{
return m_pimpl->m_hasVertical;
}
//=============================================================================
//==================== TFontManager =====================================
//=============================================================================
//---------------------------------------------------------
struct TFontManager::Impl {
WindowsFontTable m_families;
bool m_loaded;
LOGFONTW m_currentLogFont;
TFont *m_currentFont;
// this option is set by library user when he wants to write vertically.
// In this implementation, if m_vertical is true and the font
// has the @-version, the library use it.
bool m_vertical;
TFontManager::Impl()
: m_loaded(false), m_currentFont(0), m_vertical(false)
{
}
};
//---------------------------------------------------------
TFontManager::TFontManager()
{
m_pimpl = new TFontManager::Impl();
}
//---------------------------------------------------------
TFontManager::~TFontManager()
{
delete m_pimpl;
}
//---------------------------------------------------------
TFontManager *TFontManager::instance()
{
static TFontManager theManager;
return &theManager;
}
//---------------------------------------------------------
namespace
{
BOOL CALLBACK EnumFamCallBack(
CONST LOGFONTW *lplf,
CONST TEXTMETRICW *,
DWORD FontType,
LPARAM data)
{
if (FontType & TRUETYPE_FONTTYPE) {
LOGFONTW newLplf = *lplf;
newLplf.lfHeight = 200;
newLplf.lfWidth = 0;
WindowsFontTable &table = *(WindowsFontTable *)data;
table[lplf->lfFaceName] = newLplf;
return TRUE;
}
return TRUE;
}
}
//---------------------------------------------------------
void TFontManager::loadFontNames()
{
if (m_pimpl->m_loaded)
return;
HDC hdc = CreateCompatibleDC(NULL);
if (!hdc)
throw TFontLibraryLoadingError();
EnumFontFamiliesW(hdc,
(LPCWSTR)NULL,
(FONTENUMPROCW)EnumFamCallBack,
(LPARAM) & (m_pimpl->m_families));
DeleteDC(hdc);
hdc = 0;
if (m_pimpl->m_families.empty())
throw TFontLibraryLoadingError();
m_pimpl->m_loaded = true;
}
//---------------------------------------------------------
void TFontManager::setFamily(const wstring family)
{
wstring userFamilyName = ((family.c_str())[0] == L'@') ? wstring(family.c_str() + 1) : family;
wstring realFamilyName = (m_pimpl->m_vertical && (family.c_str())[0] != L'@') ? L"@" + family : family;
wstring currentFamilyName = wstring(m_pimpl->m_currentLogFont.lfFaceName);
if (currentFamilyName == realFamilyName)
return;
LOGFONTW logfont;
if (m_pimpl->m_vertical) {
WindowsFontTable::iterator it = m_pimpl->m_families.find(realFamilyName);
if (it != m_pimpl->m_families.end())
logfont = it->second;
else {
it = m_pimpl->m_families.find(userFamilyName);
assert(it != m_pimpl->m_families.end());
if (it != m_pimpl->m_families.end())
logfont = it->second;
else
throw TFontCreationError();
}
} else {
WindowsFontTable::iterator it = m_pimpl->m_families.find(userFamilyName);
assert(it != m_pimpl->m_families.end());
if (it != m_pimpl->m_families.end())
logfont = it->second;
else
throw TFontCreationError();
}
if (m_pimpl->m_currentFont) {
logfont.lfHeight = m_pimpl->m_currentLogFont.lfHeight;
logfont.lfItalic = m_pimpl->m_currentLogFont.lfItalic;
logfont.lfWeight = m_pimpl->m_currentLogFont.lfWeight;
} else
logfont.lfHeight = 200;
try {
HDC hdc = CreateCompatibleDC(NULL);
TFont *newfont = new TFont(logfont, hdc);
delete m_pimpl->m_currentFont;
m_pimpl->m_currentFont = newfont;
m_pimpl->m_currentLogFont = logfont;
} catch (TException &) {
throw TFontCreationError();
}
}
//---------------------------------------------------------
void TFontManager::setTypeface(const wstring typeface)
{
LOGFONTW logfont = m_pimpl->m_currentLogFont;
logfont.lfItalic = (typeface == L"Italic" ||
typeface == L"Bold Italic")
? TRUE
: FALSE;
logfont.lfWeight = (typeface == L"Bold" ||
typeface == L"Bold Italic")
? 700
: 400;
try {
HDC hdc = CreateCompatibleDC(NULL);
TFont *newfont = new TFont(logfont, hdc);
delete m_pimpl->m_currentFont;
m_pimpl->m_currentFont = newfont;
m_pimpl->m_currentLogFont = logfont;
} catch (TException &) {
throw TFontCreationError();
}
}
//---------------------------------------------------------
void TFontManager::setSize(int size)
{
LOGFONTW logfont = m_pimpl->m_currentLogFont;
logfont.lfHeight = size;
try {
HDC hdc = CreateCompatibleDC(NULL);
TFont *newfont = new TFont(logfont, hdc);
delete m_pimpl->m_currentFont;
m_pimpl->m_currentFont = newfont;
m_pimpl->m_currentLogFont = logfont;
} catch (TException &) {
throw TFontCreationError();
}
}
//---------------------------------------------------------
wstring TFontManager::getCurrentFamily() const
{
wstring currentFamilyName = (m_pimpl->m_currentLogFont.lfFaceName[0] == L'@') ? wstring(m_pimpl->m_currentLogFont.lfFaceName + 1) : wstring(m_pimpl->m_currentLogFont.lfFaceName);
return currentFamilyName;
}
//---------------------------------------------------------
wstring TFontManager::getCurrentTypeface() const
{
if (m_pimpl->m_currentLogFont.lfItalic) {
if (m_pimpl->m_currentLogFont.lfWeight == 700)
return L"Bold Italic";
else
return L"Italic";
} else {
if (m_pimpl->m_currentLogFont.lfWeight == 700)
return L"Bold";
else
return L"Regular";
}
}
//---------------------------------------------------------
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(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());
WindowsFontTable::iterator it = m_pimpl->m_families.begin();
for (; it != m_pimpl->m_families.end(); ++it) {
if ((it->first)[0] != L'@')
families.push_back(it->first);
}
}
//---------------------------------------------------------
void TFontManager::getAllTypefaces(vector<wstring> &typefaces) const
{
typefaces.resize(4);
typefaces[0] = L"Regular";
typefaces[1] = L"Italic";
typefaces[2] = L"Bold";
typefaces[3] = L"Bold Italic";
}
//---------------------------------------------------------
void TFontManager::setVertical(bool vertical)
{
if (m_pimpl->m_vertical == vertical)
return;
m_pimpl->m_vertical = vertical;
wstring currentFamilyName = (m_pimpl->m_currentLogFont.lfFaceName[0] == L'@') ? wstring(m_pimpl->m_currentLogFont.lfFaceName + 1) : wstring(m_pimpl->m_currentLogFont.lfFaceName);
if (vertical)
currentFamilyName = L'@' + currentFamilyName;
setFamily(currentFamilyName);
}