642 lines
18 KiB
C++
642 lines
18 KiB
C++
|
|
|
|
// 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;
|
|
break;
|
|
default:
|
|
tarPix->value = (srcPix->value << 2) - 1;
|
|
break;
|
|
}
|
|
++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);
|
|
}
|