1275 lines
43 KiB
C++
1275 lines
43 KiB
C++
/****************************************************************************
|
|
**
|
|
** Copyright (C) 2016 The Qt Company Ltd.
|
|
** Contact: https://www.qt.io/licensing/
|
|
**
|
|
** This file is part of the QtGui module of the Qt Toolkit.
|
|
**
|
|
** $QT_BEGIN_LICENSE:LGPL$
|
|
** Commercial License Usage
|
|
** Licensees holding valid commercial Qt licenses may use this file in
|
|
** accordance with the commercial license agreement provided with the
|
|
** Software or, alternatively, in accordance with the terms contained in
|
|
** a written agreement between you and The Qt Company. For licensing terms
|
|
** and conditions see https://www.qt.io/terms-conditions. For further
|
|
** information use the contact form at https://www.qt.io/contact-us.
|
|
**
|
|
** GNU Lesser General Public License Usage
|
|
** Alternatively, this file may be used under the terms of the GNU Lesser
|
|
** General Public License version 3 as published by the Free Software
|
|
** Foundation and appearing in the file LICENSE.LGPL3 included in the
|
|
** packaging of this file. Please review the following information to
|
|
** ensure the GNU Lesser General Public License version 3 requirements
|
|
** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
|
|
**
|
|
** GNU General Public License Usage
|
|
** Alternatively, this file may be used under the terms of the GNU
|
|
** General Public License version 2.0 or (at your option) the GNU General
|
|
** Public license version 3 or any later version approved by the KDE Free
|
|
** Qt Foundation. The licenses are as published by the Free Software
|
|
** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
|
|
** included in the packaging of this file. Please review the following
|
|
** information to ensure the GNU General Public License requirements will
|
|
** be met: https://www.gnu.org/licenses/gpl-2.0.html and
|
|
** https://www.gnu.org/licenses/gpl-3.0.html.
|
|
**
|
|
** $QT_END_LICENSE$
|
|
**
|
|
****************************************************************************/
|
|
|
|
#include "qfontsubset_p.h"
|
|
#include <qdebug.h>
|
|
#include <qendian.h>
|
|
#include <qpainterpath.h>
|
|
#include "private/qpdf_p.h"
|
|
|
|
#include "qfontsubset_agl.cpp"
|
|
|
|
#include <algorithm>
|
|
|
|
QT_BEGIN_NAMESPACE
|
|
|
|
// This map is used for symbol fonts to get the correct glyph names for the latin range
|
|
static const unsigned short symbol_map[0x100] = {
|
|
0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
|
|
0x0008, 0x0009, 0x000a, 0x000b, 0x000c, 0x000d, 0x000e, 0x000f,
|
|
0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
|
|
0x0018, 0x0019, 0x001a, 0x001b, 0x001c, 0x001d, 0x001e, 0x001f,
|
|
0x0020, 0x0021, 0x2200, 0x0023, 0x2203, 0x0025, 0x0026, 0x220b,
|
|
0x0028, 0x0029, 0x2217, 0x002b, 0x002c, 0x2212, 0x002e, 0x002f,
|
|
0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
|
|
0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f,
|
|
|
|
0x2245, 0x0391, 0x0392, 0x03a7, 0x0394, 0x0395, 0x03a6, 0x0393,
|
|
0x0397, 0x0399, 0x03d1, 0x039a, 0x039b, 0x039c, 0x039d, 0x039f,
|
|
0x03a0, 0x0398, 0x03a1, 0x03a3, 0x03a4, 0x03a5, 0x03c2, 0x03a9,
|
|
0x039e, 0x03a8, 0x0396, 0x005b, 0x2234, 0x005d, 0x22a5, 0x005f,
|
|
0xf8e5, 0x03b1, 0x03b2, 0x03c7, 0x03b4, 0x03b5, 0x03c6, 0x03b3,
|
|
0x03b7, 0x03b9, 0x03d5, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03bf,
|
|
0x03c0, 0x03b8, 0x03c1, 0x03c3, 0x03c4, 0x03c5, 0x03d6, 0x03c9,
|
|
0x03be, 0x03c8, 0x03b6, 0x007b, 0x007c, 0x007d, 0x223c, 0x007f,
|
|
|
|
0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
|
|
0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
|
|
0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
|
|
0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
|
|
0x20ac, 0x03d2, 0x2023, 0x2264, 0x2044, 0x221e, 0x0192, 0x2263,
|
|
0x2666, 0x2665, 0x2660, 0x2194, 0x2190, 0x2191, 0x2192, 0x2193,
|
|
0x00b0, 0x00b1, 0x2033, 0x2265, 0x00d7, 0x221d, 0x2202, 0x2022,
|
|
0x00f7, 0x2260, 0x2261, 0x2248, 0x2026, 0xf8e6, 0xf8e7, 0x21b5,
|
|
|
|
0x2135, 0x2111, 0x211c, 0x2118, 0x2297, 0x2295, 0x2205, 0x2229,
|
|
0x222a, 0x2283, 0x2287, 0x2284, 0x2282, 0x2286, 0x2208, 0x2209,
|
|
0x2220, 0x2207, 0xf6da, 0xf6d9, 0xf6db, 0x220f, 0x221a, 0x22c5,
|
|
0x00ac, 0x2227, 0x2228, 0x21d4, 0x21d0, 0x21d1, 0x21d2, 0x21d3,
|
|
0x25ca, 0x2329, 0xf8e8, 0xf8e9, 0xf8ea, 0x2211, 0xf8eb, 0xf8ec,
|
|
0xf8ed, 0xf8ee, 0xf8ef, 0xf8f0, 0xf8f1, 0xf8f2, 0xf8f3, 0xf8f4,
|
|
0x0000, 0x232a, 0x222b, 0x2320, 0xf8f5, 0x2321, 0xf8f6, 0xf8f7,
|
|
0xf8f8, 0xf8f9, 0xf8fa, 0xf8fb, 0xf8fc, 0xf8fd, 0xf8fe, 0x0000
|
|
};
|
|
|
|
// ---------------------------- PS/PDF helper methods -----------------------------------
|
|
|
|
#ifndef QT_NO_PDF
|
|
|
|
QByteArray QFontSubset::glyphName(unsigned short unicode, bool symbol)
|
|
{
|
|
if (symbol && unicode < 0x100)
|
|
// map from latin1 to symbol
|
|
unicode = symbol_map[unicode];
|
|
|
|
const AGLEntry *r = std::lower_bound(unicode_to_agl_map, unicode_to_agl_map + unicode_to_agl_map_size, unicode);
|
|
if ((r != unicode_to_agl_map + unicode_to_agl_map_size) && !(unicode < *r))
|
|
return glyph_names + r->index;
|
|
|
|
char buffer[8];
|
|
buffer[0] = 'u';
|
|
buffer[1] = 'n';
|
|
buffer[2] = 'i';
|
|
QPdf::toHex(unicode, buffer+3);
|
|
return buffer;
|
|
}
|
|
|
|
QByteArray QFontSubset::glyphName(unsigned int glyph, const QVector<int> &reverseMap) const
|
|
{
|
|
uint glyphIndex = glyph_indices[glyph];
|
|
|
|
if (glyphIndex == 0)
|
|
return "/.notdef";
|
|
|
|
QByteArray ba;
|
|
QPdf::ByteStream s(&ba);
|
|
if (reverseMap[glyphIndex] && reverseMap[glyphIndex] < 0x10000) {
|
|
s << '/' << glyphName(reverseMap[glyphIndex], false);
|
|
} else {
|
|
s << "/gl" << (int)glyphIndex;
|
|
}
|
|
return ba;
|
|
}
|
|
|
|
|
|
QByteArray QFontSubset::widthArray() const
|
|
{
|
|
Q_ASSERT(!widths.isEmpty());
|
|
|
|
QFontEngine::Properties properties = fontEngine->properties();
|
|
|
|
QByteArray width;
|
|
QPdf::ByteStream s(&width);
|
|
const qreal scale = 1000.0/emSquare.toInt();
|
|
|
|
QFixed defWidth = widths[0];
|
|
//qDebug("defWidth=%d, scale=%f", defWidth.toInt(), scale.toReal());
|
|
for (int i = 0; i < nGlyphs(); ++i) {
|
|
if (defWidth != widths[i])
|
|
defWidth = 0;
|
|
}
|
|
if (defWidth > 0) {
|
|
s << "/DW " << qRound(defWidth.toInt() * scale);
|
|
} else {
|
|
s << "/W [";
|
|
for (int g = 0; g < nGlyphs();) {
|
|
QFixed w = widths[g];
|
|
int start = g;
|
|
int startLinear = 0;
|
|
++g;
|
|
while (g < nGlyphs()) {
|
|
QFixed nw = widths[g];
|
|
if (nw == w) {
|
|
if (!startLinear)
|
|
startLinear = g - 1;
|
|
} else {
|
|
if (startLinear > 0 && g - startLinear >= 10)
|
|
break;
|
|
startLinear = 0;
|
|
}
|
|
w = nw;
|
|
++g;
|
|
}
|
|
// qDebug("start=%x startLinear=%x g-1=%x",start,startLinear,g-1);
|
|
if (g - startLinear < 10)
|
|
startLinear = 0;
|
|
int endnonlinear = startLinear ? startLinear : g;
|
|
// qDebug(" startLinear=%x endnonlinear=%x", startLinear,endnonlinear);
|
|
if (endnonlinear > start) {
|
|
s << start << '[';
|
|
for (int i = start; i < endnonlinear; ++i)
|
|
s << qRound(widths[i].toInt() * scale);
|
|
s << "]\n";
|
|
}
|
|
if (startLinear)
|
|
s << startLinear << g - 1 << qRound(widths[startLinear].toInt() * scale) << '\n';
|
|
}
|
|
s << "]\n";
|
|
}
|
|
return width;
|
|
}
|
|
|
|
static void checkRanges(QPdf::ByteStream &ts, QByteArray &ranges, int &nranges)
|
|
{
|
|
if (++nranges > 100) {
|
|
ts << nranges << "beginbfrange\n"
|
|
<< ranges << "endbfrange\n";
|
|
ranges = QByteArray();
|
|
nranges = 0;
|
|
}
|
|
}
|
|
|
|
QVector<int> QFontSubset::getReverseMap() const
|
|
{
|
|
QVector<int> reverseMap(0x10000, 0);
|
|
for (uint uc = 0; uc < 0x10000; ++uc) {
|
|
int idx = glyph_indices.indexOf(fontEngine->glyphIndex(uc));
|
|
if (idx >= 0 && !reverseMap.at(idx))
|
|
reverseMap[idx] = uc;
|
|
}
|
|
return reverseMap;
|
|
}
|
|
|
|
QByteArray QFontSubset::createToUnicodeMap() const
|
|
{
|
|
QVector<int> reverseMap = getReverseMap();
|
|
|
|
QByteArray touc;
|
|
QPdf::ByteStream ts(&touc);
|
|
ts << "/CIDInit /ProcSet findresource begin\n"
|
|
"12 dict begin\n"
|
|
"begincmap\n"
|
|
"/CIDSystemInfo << /Registry (Adobe) /Ordering (UCS) /Supplement 0 >> def\n"
|
|
"/CMapName /Adobe-Identity-UCS def\n"
|
|
"/CMapType 2 def\n"
|
|
"1 begincodespacerange\n"
|
|
"<0000> <FFFF>\n"
|
|
"endcodespacerange\n";
|
|
|
|
int nranges = 1;
|
|
QByteArray ranges = "<0000> <0000> <0000>\n";
|
|
QPdf::ByteStream s(&ranges);
|
|
|
|
char buf[5];
|
|
for (int g = 1; g < nGlyphs(); ) {
|
|
int uc0 = reverseMap.at(g);
|
|
if (!uc0) {
|
|
++g;
|
|
continue;
|
|
}
|
|
int start = g;
|
|
int startLinear = 0;
|
|
++g;
|
|
while (g < nGlyphs()) {
|
|
int uc = reverseMap[g];
|
|
// cmaps can't have the high byte changing within one range, so we need to break on that as well
|
|
if (!uc || (g>>8) != (start >> 8))
|
|
break;
|
|
if (uc == uc0 + 1) {
|
|
if (!startLinear)
|
|
startLinear = g - 1;
|
|
} else {
|
|
if (startLinear > 0 && g - startLinear >= 10)
|
|
break;
|
|
startLinear = 0;
|
|
}
|
|
uc0 = uc;
|
|
++g;
|
|
}
|
|
// qDebug("start=%x startLinear=%x g-1=%x",start,startLinear,g-1);
|
|
if (g - startLinear < 10)
|
|
startLinear = 0;
|
|
int endnonlinear = startLinear ? startLinear : g;
|
|
// qDebug(" startLinear=%x endnonlinear=%x", startLinear,endnonlinear);
|
|
if (endnonlinear > start) {
|
|
s << '<' << QPdf::toHex((ushort)start, buf) << "> <";
|
|
s << QPdf::toHex((ushort)(endnonlinear - 1), buf) << "> ";
|
|
if (endnonlinear == start + 1) {
|
|
s << '<' << QPdf::toHex((ushort)reverseMap[start], buf) << ">\n";
|
|
} else {
|
|
s << '[';
|
|
for (int i = start; i < endnonlinear; ++i) {
|
|
s << '<' << QPdf::toHex((ushort)reverseMap[i], buf) << "> ";
|
|
}
|
|
s << "]\n";
|
|
}
|
|
checkRanges(ts, ranges, nranges);
|
|
}
|
|
if (startLinear) {
|
|
while (startLinear < g) {
|
|
int len = g - startLinear;
|
|
int uc_start = reverseMap[startLinear];
|
|
int uc_end = uc_start + len - 1;
|
|
if ((uc_end >> 8) != (uc_start >> 8))
|
|
len = 256 - (uc_start & 0xff);
|
|
s << '<' << QPdf::toHex((ushort)startLinear, buf) << "> <";
|
|
s << QPdf::toHex((ushort)(startLinear + len - 1), buf) << "> ";
|
|
s << '<' << QPdf::toHex((ushort)reverseMap[startLinear], buf) << ">\n";
|
|
checkRanges(ts, ranges, nranges);
|
|
startLinear += len;
|
|
}
|
|
}
|
|
}
|
|
if (nranges) {
|
|
ts << nranges << "beginbfrange\n"
|
|
<< ranges << "endbfrange\n";
|
|
}
|
|
ts << "endcmap\n"
|
|
"CMapName currentdict /CMap defineresource pop\n"
|
|
"end\n"
|
|
"end\n";
|
|
|
|
return touc;
|
|
}
|
|
|
|
int QFontSubset::addGlyph(int index)
|
|
{
|
|
int idx = glyph_indices.indexOf(index);
|
|
if (idx < 0) {
|
|
idx = glyph_indices.size();
|
|
glyph_indices.append(index);
|
|
}
|
|
return idx;
|
|
}
|
|
|
|
#endif // QT_NO_PDF
|
|
|
|
// ------------------------------ Truetype generation ----------------------------------------------
|
|
|
|
typedef qint16 F2DOT14;
|
|
typedef quint32 Tag;
|
|
typedef quint16 GlyphID;
|
|
typedef quint16 Offset;
|
|
|
|
|
|
class QTtfStream {
|
|
public:
|
|
QTtfStream(QByteArray &ba) : data((uchar *)ba.data()) { start = data; }
|
|
QTtfStream &operator <<(quint8 v) { *data = v; ++data; return *this; }
|
|
QTtfStream &operator <<(quint16 v) { qToBigEndian(v, data); data += sizeof(v); return *this; }
|
|
QTtfStream &operator <<(quint32 v) { qToBigEndian(v, data); data += sizeof(v); return *this; }
|
|
QTtfStream &operator <<(qint8 v) { *data = quint8(v); ++data; return *this; }
|
|
QTtfStream &operator <<(qint16 v) { qToBigEndian(v, data); data += sizeof(v); return *this; }
|
|
QTtfStream &operator <<(qint32 v) { qToBigEndian(v, data); data += sizeof(v); return *this; }
|
|
QTtfStream &operator <<(qint64 v) { qToBigEndian(v, data); data += sizeof(v); return *this; }
|
|
|
|
int offset() const { return data - start; }
|
|
void setOffset(int o) { data = start + o; }
|
|
void align4() { while (offset() & 3) { *data = '\0'; ++data; } }
|
|
private:
|
|
uchar *data;
|
|
uchar *start;
|
|
};
|
|
|
|
struct QTtfTable {
|
|
Tag tag;
|
|
QByteArray data;
|
|
};
|
|
Q_DECLARE_TYPEINFO(QTtfTable, Q_MOVABLE_TYPE);
|
|
|
|
|
|
struct qttf_head_table {
|
|
qint32 font_revision;
|
|
quint16 flags;
|
|
qint64 created;
|
|
qint64 modified;
|
|
qint16 xMin;
|
|
qint16 yMin;
|
|
qint16 xMax;
|
|
qint16 yMax;
|
|
quint16 macStyle;
|
|
qint16 indexToLocFormat;
|
|
};
|
|
Q_DECLARE_TYPEINFO(qttf_head_table, Q_PRIMITIVE_TYPE);
|
|
|
|
|
|
struct qttf_hhea_table {
|
|
qint16 ascender;
|
|
qint16 descender;
|
|
qint16 lineGap;
|
|
quint16 maxAdvanceWidth;
|
|
qint16 minLeftSideBearing;
|
|
qint16 minRightSideBearing;
|
|
qint16 xMaxExtent;
|
|
quint16 numberOfHMetrics;
|
|
};
|
|
Q_DECLARE_TYPEINFO(qttf_hhea_table, Q_PRIMITIVE_TYPE);
|
|
|
|
|
|
struct qttf_maxp_table {
|
|
quint16 numGlyphs;
|
|
quint16 maxPoints;
|
|
quint16 maxContours;
|
|
quint16 maxCompositePoints;
|
|
quint16 maxCompositeContours;
|
|
quint16 maxComponentElements;
|
|
quint16 maxComponentDepth;
|
|
};
|
|
Q_DECLARE_TYPEINFO(qttf_maxp_table, Q_PRIMITIVE_TYPE);
|
|
|
|
struct qttf_name_table {
|
|
QString copyright;
|
|
QString family;
|
|
QString subfamily;
|
|
QString postscript_name;
|
|
};
|
|
Q_DECLARE_TYPEINFO(qttf_name_table, Q_MOVABLE_TYPE);
|
|
|
|
|
|
static QTtfTable generateHead(const qttf_head_table &head);
|
|
static QTtfTable generateHhea(const qttf_hhea_table &hhea);
|
|
static QTtfTable generateMaxp(const qttf_maxp_table &maxp);
|
|
static QTtfTable generateName(const qttf_name_table &name);
|
|
|
|
struct qttf_font_tables
|
|
{
|
|
qttf_head_table head;
|
|
qttf_hhea_table hhea;
|
|
qttf_maxp_table maxp;
|
|
};
|
|
|
|
|
|
struct QTtfGlyph {
|
|
quint16 index;
|
|
qint16 xMin;
|
|
qint16 xMax;
|
|
qint16 yMin;
|
|
qint16 yMax;
|
|
quint16 advanceWidth;
|
|
qint16 lsb;
|
|
quint16 numContours;
|
|
quint16 numPoints;
|
|
QByteArray data;
|
|
};
|
|
Q_DECLARE_TYPEINFO(QTtfGlyph, Q_MOVABLE_TYPE);
|
|
|
|
static QTtfGlyph generateGlyph(int index, const QPainterPath &path, qreal advance, qreal lsb, qreal ppem);
|
|
// generates glyf, loca and hmtx
|
|
static QVector<QTtfTable> generateGlyphTables(qttf_font_tables &tables, const QVector<QTtfGlyph> &_glyphs);
|
|
|
|
static QByteArray bindFont(const QVector<QTtfTable>& _tables);
|
|
|
|
|
|
static quint32 checksum(const QByteArray &table)
|
|
{
|
|
quint32 sum = 0;
|
|
int offset = 0;
|
|
const uchar *d = (const uchar *)table.constData();
|
|
while (offset <= table.size()-3) {
|
|
sum += qFromBigEndian<quint32>(d + offset);
|
|
offset += 4;
|
|
}
|
|
int shift = 24;
|
|
quint32 x = 0;
|
|
while (offset < table.size()) {
|
|
x |= ((quint32)d[offset]) << shift;
|
|
++offset;
|
|
shift -= 8;
|
|
}
|
|
sum += x;
|
|
|
|
return sum;
|
|
}
|
|
|
|
static QTtfTable generateHead(const qttf_head_table &head)
|
|
{
|
|
const int head_size = 54;
|
|
QTtfTable t;
|
|
t.tag = MAKE_TAG('h', 'e', 'a', 'd');
|
|
t.data.resize(head_size);
|
|
|
|
QTtfStream s(t.data);
|
|
|
|
// qint32 Table version number 0x00010000 for version 1.0.
|
|
// qint32 fontRevision Set by font manufacturer.
|
|
s << qint32(0x00010000)
|
|
<< head.font_revision
|
|
// quint32 checkSumAdjustment To compute: set it to 0, sum the entire font as quint32, then store 0xB1B0AFBA - sum.
|
|
<< quint32(0)
|
|
// quint32 magicNumber Set to 0x5F0F3CF5.
|
|
<< quint32(0x5F0F3CF5)
|
|
// quint16 flags Bit 0: Baseline for font at y=0;
|
|
// Bit 1: Left sidebearing point at x=0;
|
|
// Bit 2: Instructions may depend on point size;
|
|
// Bit 3: Force ppem to integer values for all internal scaler math; may use fractional ppem sizes if this bit is clear;
|
|
// Bit 4: Instructions may alter advance width (the advance widths might not scale linearly);
|
|
// Bits 5-10: These should be set according to Apple's specification . However, they are not implemented in OpenType.
|
|
// Bit 11: Font data is 'lossless,' as a result of having been compressed and decompressed with the Agfa MicroType Express engine.
|
|
// Bit 12: Font converted (produce compatible metrics)
|
|
// Bit 13: Font optimized for ClearType
|
|
// Bit 14: Reserved, set to 0
|
|
// Bit 15: Reserved, set to 0
|
|
<< quint16(0)
|
|
|
|
// quint16 unitsPerEm Valid range is from 16 to 16384. This value should be a power of 2 for fonts that have TrueType outlines.
|
|
<< quint16(2048)
|
|
// qint64 created Number of seconds since 12:00 midnight, January 1, 1904. 64-bit integer
|
|
<< head.created
|
|
// qint64 modified Number of seconds since 12:00 midnight, January 1, 1904. 64-bit integer
|
|
<< head.modified
|
|
// qint16 xMin For all glyph bounding boxes.
|
|
// qint16 yMin For all glyph bounding boxes.
|
|
// qint16 xMax For all glyph bounding boxes.
|
|
// qint16 yMax For all glyph bounding boxes.
|
|
<< head.xMin
|
|
<< head.yMin
|
|
<< head.xMax
|
|
<< head.yMax
|
|
// quint16 macStyle Bit 0: Bold (if set to 1);
|
|
// Bit 1: Italic (if set to 1)
|
|
// Bit 2: Underline (if set to 1)
|
|
// Bit 3: Outline (if set to 1)
|
|
// Bit 4: Shadow (if set to 1)
|
|
// Bit 5: Condensed (if set to 1)
|
|
// Bit 6: Extended (if set to 1)
|
|
// Bits 7-15: Reserved (set to 0).
|
|
<< head.macStyle
|
|
// quint16 lowestRecPPEM Smallest readable size in pixels.
|
|
<< quint16(6) // just a wild guess
|
|
// qint16 fontDirectionHint 0: Fully mixed directional glyphs;
|
|
<< qint16(0)
|
|
// 1: Only strongly left to right;
|
|
// 2: Like 1 but also contains neutrals;
|
|
// -1: Only strongly right to left;
|
|
// -2: Like -1 but also contains neutrals. 1
|
|
// qint16 indexToLocFormat 0 for short offsets, 1 for long.
|
|
<< head.indexToLocFormat
|
|
// qint16 glyphDataFormat 0 for current format.
|
|
<< qint16(0);
|
|
|
|
Q_ASSERT(s.offset() == head_size);
|
|
return t;
|
|
}
|
|
|
|
|
|
static QTtfTable generateHhea(const qttf_hhea_table &hhea)
|
|
{
|
|
const int hhea_size = 36;
|
|
QTtfTable t;
|
|
t.tag = MAKE_TAG('h', 'h', 'e', 'a');
|
|
t.data.resize(hhea_size);
|
|
|
|
QTtfStream s(t.data);
|
|
// qint32 Table version number 0x00010000 for version 1.0.
|
|
s << qint32(0x00010000)
|
|
// qint16 Ascender Typographic ascent. (Distance from baseline of highest ascender)
|
|
<< hhea.ascender
|
|
// qint16 Descender Typographic descent. (Distance from baseline of lowest descender)
|
|
<< hhea.descender
|
|
// qint16 LineGap Typographic line gap.
|
|
// Negative LineGap values are treated as zero
|
|
// in Windows 3.1, System 6, and
|
|
// System 7.
|
|
<< hhea.lineGap
|
|
// quint16 advanceWidthMax Maximum advance width value in 'hmtx' table.
|
|
<< hhea.maxAdvanceWidth
|
|
// qint16 minLeftSideBearing Minimum left sidebearing value in 'hmtx' table.
|
|
<< hhea.minLeftSideBearing
|
|
// qint16 minRightSideBearing Minimum right sidebearing value; calculated as Min(aw - lsb - (xMax - xMin)).
|
|
<< hhea.minRightSideBearing
|
|
// qint16 xMaxExtent Max(lsb + (xMax - xMin)).
|
|
<< hhea.xMaxExtent
|
|
// qint16 caretSlopeRise Used to calculate the slope of the cursor (rise/run); 1 for vertical.
|
|
<< qint16(1)
|
|
// qint16 caretSlopeRun 0 for vertical.
|
|
<< qint16(0)
|
|
// qint16 caretOffset The amount by which a slanted highlight on a glyph needs to be shifted to produce the best appearance. Set to 0 for non-slanted fonts
|
|
<< qint16(0)
|
|
// qint16 (reserved) set to 0
|
|
<< qint16(0)
|
|
// qint16 (reserved) set to 0
|
|
<< qint16(0)
|
|
// qint16 (reserved) set to 0
|
|
<< qint16(0)
|
|
// qint16 (reserved) set to 0
|
|
<< qint16(0)
|
|
// qint16 metricDataFormat 0 for current format.
|
|
<< qint16(0)
|
|
// quint16 numberOfHMetrics Number of hMetric entries in 'hmtx' table
|
|
<< hhea.numberOfHMetrics;
|
|
|
|
Q_ASSERT(s.offset() == hhea_size);
|
|
return t;
|
|
}
|
|
|
|
|
|
static QTtfTable generateMaxp(const qttf_maxp_table &maxp)
|
|
{
|
|
const int maxp_size = 32;
|
|
QTtfTable t;
|
|
t.tag = MAKE_TAG('m', 'a', 'x', 'p');
|
|
t.data.resize(maxp_size);
|
|
|
|
QTtfStream s(t.data);
|
|
|
|
// qint32 Table version number 0x00010000 for version 1.0.
|
|
s << qint32(0x00010000)
|
|
// quint16 numGlyphs The number of glyphs in the font.
|
|
<< maxp.numGlyphs
|
|
// quint16 maxPoints Maximum points in a non-composite glyph.
|
|
<< maxp.maxPoints
|
|
// quint16 maxContours Maximum contours in a non-composite glyph.
|
|
<< maxp.maxContours
|
|
// quint16 maxCompositePoints Maximum points in a composite glyph.
|
|
<< maxp.maxCompositePoints
|
|
// quint16 maxCompositeContours Maximum contours in a composite glyph.
|
|
<< maxp.maxCompositeContours
|
|
// quint16 maxZones 1 if instructions do not use the twilight zone (Z0), or 2 if instructions do use Z0; should be set to 2 in most cases.
|
|
<< quint16(1) // we do not embed instructions
|
|
// quint16 maxTwilightPoints Maximum points used in Z0.
|
|
<< quint16(0)
|
|
// quint16 maxStorage Number of Storage Area locations.
|
|
<< quint16(0)
|
|
// quint16 maxFunctionDefs Number of FDEFs.
|
|
<< quint16(0)
|
|
// quint16 maxInstructionDefs Number of IDEFs.
|
|
<< quint16(0)
|
|
// quint16 maxStackElements Maximum stack depth2.
|
|
<< quint16(0)
|
|
// quint16 maxSizeOfInstructions Maximum byte count for glyph instructions.
|
|
<< quint16(0)
|
|
// quint16 maxComponentElements Maximum number of components referenced at "top level" for any composite glyph.
|
|
<< maxp.maxComponentElements
|
|
// quint16 maxComponentDepth Maximum levels of recursion; 1 for simple components.
|
|
<< maxp.maxComponentDepth;
|
|
|
|
Q_ASSERT(s.offset() == maxp_size);
|
|
return t;
|
|
}
|
|
|
|
struct QTtfNameRecord {
|
|
quint16 nameId;
|
|
QString value;
|
|
};
|
|
Q_DECLARE_TYPEINFO(QTtfNameRecord, Q_MOVABLE_TYPE);
|
|
|
|
static QTtfTable generateName(const QVector<QTtfNameRecord> &name);
|
|
|
|
static QTtfTable generateName(const qttf_name_table &name)
|
|
{
|
|
QVector<QTtfNameRecord> list;
|
|
list.reserve(5);
|
|
QTtfNameRecord rec;
|
|
rec.nameId = 0;
|
|
rec.value = name.copyright;
|
|
list.append(rec);
|
|
rec.nameId = 1;
|
|
rec.value = name.family;
|
|
list.append(rec);
|
|
rec.nameId = 2;
|
|
rec.value = name.subfamily;
|
|
list.append(rec);
|
|
rec.nameId = 4;
|
|
rec.value = name.family;
|
|
if (name.subfamily != QLatin1String("Regular"))
|
|
rec.value += QLatin1Char(' ') + name.subfamily;
|
|
list.append(rec);
|
|
rec.nameId = 6;
|
|
rec.value = name.postscript_name;
|
|
list.append(rec);
|
|
|
|
return generateName(list);
|
|
}
|
|
|
|
// ####### should probably generate Macintosh/Roman name entries as well
|
|
static QTtfTable generateName(const QVector<QTtfNameRecord> &name)
|
|
{
|
|
const int char_size = 2;
|
|
|
|
QTtfTable t;
|
|
t.tag = MAKE_TAG('n', 'a', 'm', 'e');
|
|
|
|
const int name_size = 6 + 12*name.size();
|
|
int string_size = 0;
|
|
for (int i = 0; i < name.size(); ++i) {
|
|
string_size += name.at(i).value.length()*char_size;
|
|
}
|
|
t.data.resize(name_size + string_size);
|
|
|
|
QTtfStream s(t.data);
|
|
// quint16 format Format selector (=0).
|
|
s << quint16(0)
|
|
// quint16 count Number of name records.
|
|
<< quint16(name.size())
|
|
// quint16 stringOffset Offset to start of string storage (from start of table).
|
|
<< quint16(name_size);
|
|
// NameRecord nameRecord[count] The name records where count is the number of records.
|
|
// (Variable)
|
|
|
|
int off = 0;
|
|
for (int i = 0; i < name.size(); ++i) {
|
|
int len = name.at(i).value.length()*char_size;
|
|
// quint16 platformID Platform ID.
|
|
// quint16 encodingID Platform-specific encoding ID.
|
|
// quint16 languageID Language ID.
|
|
s << quint16(3)
|
|
<< quint16(1)
|
|
<< quint16(0x0409) // en_US
|
|
// quint16 nameId Name ID.
|
|
<< name.at(i).nameId
|
|
// quint16 length String length (in bytes).
|
|
<< quint16(len)
|
|
// quint16 offset String offset from start of storage area (in bytes).
|
|
<< quint16(off);
|
|
off += len;
|
|
}
|
|
for (int i = 0; i < name.size(); ++i) {
|
|
const QString &n = name.at(i).value;
|
|
const ushort *uc = n.utf16();
|
|
for (int i = 0; i < n.length(); ++i) {
|
|
s << quint16(*uc);
|
|
++uc;
|
|
}
|
|
}
|
|
return t;
|
|
}
|
|
|
|
|
|
enum Flags {
|
|
OffCurve = 0,
|
|
OnCurve = (1 << 0),
|
|
XShortVector = (1 << 1),
|
|
YShortVector = (1 << 2),
|
|
Repeat = (1 << 3),
|
|
XSame = (1 << 4),
|
|
XShortPositive = (1 << 4),
|
|
YSame = (1 << 5),
|
|
YShortPositive = (1 << 5)
|
|
};
|
|
struct TTF_POINT {
|
|
qint16 x;
|
|
qint16 y;
|
|
quint8 flags;
|
|
};
|
|
Q_DECLARE_TYPEINFO(TTF_POINT, Q_PRIMITIVE_TYPE);
|
|
|
|
static void convertPath(const QPainterPath &path, QVector<TTF_POINT> *points, QVector<int> *endPoints, qreal ppem)
|
|
{
|
|
int numElements = path.elementCount();
|
|
for (int i = 0; i < numElements - 1; ++i) {
|
|
const QPainterPath::Element &e = path.elementAt(i);
|
|
TTF_POINT p;
|
|
p.x = qRound(e.x * 2048. / ppem);
|
|
p.y = qRound(-e.y * 2048. / ppem);
|
|
p.flags = 0;
|
|
|
|
switch(e.type) {
|
|
case QPainterPath::MoveToElement:
|
|
if (i != 0) {
|
|
// see if start and end points of the last contour agree
|
|
int start = endPoints->size() ? endPoints->at(endPoints->size()-1) - 1 : 0;
|
|
int end = points->size() - 1;
|
|
if (points->at(end).x == points->at(start).x
|
|
&& points->at(end).y == points->at(start).y)
|
|
points->takeLast();
|
|
endPoints->append(points->size() - 1);
|
|
}
|
|
Q_FALLTHROUGH();
|
|
case QPainterPath::LineToElement:
|
|
p.flags = OnCurve;
|
|
break;
|
|
case QPainterPath::CurveToElement: {
|
|
// cubic bezier curve, we need to reduce to a list of quadratic curves
|
|
TTF_POINT list[3*16 + 4]; // we need max 16 subdivisions
|
|
list[3] = points->at(points->size() - 1);
|
|
list[2] = p;
|
|
const QPainterPath::Element &e2 = path.elementAt(++i);
|
|
list[1].x = qRound(e2.x * 2048. / ppem);
|
|
list[1].y = qRound(-e2.y * 2048. / ppem);
|
|
const QPainterPath::Element &e3 = path.elementAt(++i);
|
|
list[0].x = qRound(e3.x * 2048. / ppem);
|
|
list[0].y = qRound(-e3.y * 2048. / ppem);
|
|
|
|
TTF_POINT *base = list;
|
|
|
|
bool try_reduce = points->size() > 1
|
|
&& points->at(points->size() - 1).flags == OnCurve
|
|
&& points->at(points->size() - 2).flags == OffCurve;
|
|
// qDebug("generating beziers:");
|
|
while (base >= list) {
|
|
const int split_limit = 3;
|
|
// {
|
|
// qDebug("iteration:");
|
|
// TTF_POINT *x = list;
|
|
// while (x <= base + 3) {
|
|
// qDebug() << " " << QPoint(x->x, x->y);
|
|
// ++x;
|
|
// }
|
|
// }
|
|
Q_ASSERT(base - list < 3*16 + 1);
|
|
// first see if we can easily reduce the cubic to a quadratic bezier curve
|
|
int i1_x = base[1].x + ((base[1].x - base[0].x) >> 1);
|
|
int i1_y = base[1].y + ((base[1].y - base[0].y) >> 1);
|
|
int i2_x = base[2].x + ((base[2].x - base[3].x) >> 1);
|
|
int i2_y = base[2].y + ((base[2].y - base[3].y) >> 1);
|
|
// qDebug() << "checking: i1=" << QPoint(i1_x, i1_y) << " i2=" << QPoint(i2_x, i2_y);
|
|
if (qAbs(i1_x - i2_x) <= split_limit && qAbs(i1_y - i2_y) <= split_limit) {
|
|
// got a quadratic bezier curve
|
|
TTF_POINT np;
|
|
np.x = (i1_x + i2_x) >> 1;
|
|
np.y = (i1_y + i2_y) >> 1;
|
|
if (try_reduce) {
|
|
// see if we can optimize out the last onCurve point
|
|
int mx = (points->at(points->size() - 2).x + base[2].x) >> 1;
|
|
int my = (points->at(points->size() - 2).y + base[2].y) >> 1;
|
|
if (qAbs(mx - base[3].x) <= split_limit && qAbs(my = base[3].y) <= split_limit)
|
|
points->takeLast();
|
|
try_reduce = false;
|
|
}
|
|
np.flags = OffCurve;
|
|
points->append(np);
|
|
// qDebug() << " appending offcurve point " << QPoint(np.x, np.y);
|
|
base -= 3;
|
|
} else {
|
|
// need to split
|
|
// qDebug(" -> splitting");
|
|
qint16 a, b, c, d;
|
|
base[6].x = base[3].x;
|
|
c = base[1].x;
|
|
d = base[2].x;
|
|
base[1].x = a = ( base[0].x + c ) >> 1;
|
|
base[5].x = b = ( base[3].x + d ) >> 1;
|
|
c = ( c + d ) >> 1;
|
|
base[2].x = a = ( a + c ) >> 1;
|
|
base[4].x = b = ( b + c ) >> 1;
|
|
base[3].x = ( a + b ) >> 1;
|
|
|
|
base[6].y = base[3].y;
|
|
c = base[1].y;
|
|
d = base[2].y;
|
|
base[1].y = a = ( base[0].y + c ) >> 1;
|
|
base[5].y = b = ( base[3].y + d ) >> 1;
|
|
c = ( c + d ) >> 1;
|
|
base[2].y = a = ( a + c ) >> 1;
|
|
base[4].y = b = ( b + c ) >> 1;
|
|
base[3].y = ( a + b ) >> 1;
|
|
base += 3;
|
|
}
|
|
}
|
|
p = list[0];
|
|
p.flags = OnCurve;
|
|
break;
|
|
}
|
|
case QPainterPath::CurveToDataElement:
|
|
Q_ASSERT(false);
|
|
break;
|
|
}
|
|
// qDebug() << " appending oncurve point " << QPoint(p.x, p.y);
|
|
points->append(p);
|
|
}
|
|
int start = endPoints->size() ? endPoints->at(endPoints->size()-1) + 1 : 0;
|
|
int end = points->size() - 1;
|
|
if (points->at(end).x == points->at(start).x
|
|
&& points->at(end).y == points->at(start).y)
|
|
points->takeLast();
|
|
endPoints->append(points->size() - 1);
|
|
}
|
|
|
|
static void getBounds(const QVector<TTF_POINT> &points, qint16 *xmin, qint16 *xmax, qint16 *ymin, qint16 *ymax)
|
|
{
|
|
*xmin = points.at(0).x;
|
|
*xmax = *xmin;
|
|
*ymin = points.at(0).y;
|
|
*ymax = *ymin;
|
|
|
|
for (int i = 1; i < points.size(); ++i) {
|
|
*xmin = qMin(*xmin, points.at(i).x);
|
|
*xmax = qMax(*xmax, points.at(i).x);
|
|
*ymin = qMin(*ymin, points.at(i).y);
|
|
*ymax = qMax(*ymax, points.at(i).y);
|
|
}
|
|
}
|
|
|
|
static int convertToRelative(QVector<TTF_POINT> *points)
|
|
{
|
|
// convert points to relative and setup flags
|
|
// qDebug("relative points:");
|
|
qint16 prev_x = 0;
|
|
qint16 prev_y = 0;
|
|
int point_array_size = 0;
|
|
for (int i = 0; i < points->size(); ++i) {
|
|
const int x = points->at(i).x;
|
|
const int y = points->at(i).y;
|
|
TTF_POINT rel;
|
|
rel.x = x - prev_x;
|
|
rel.y = y - prev_y;
|
|
rel.flags = points->at(i).flags;
|
|
Q_ASSERT(rel.flags < 2);
|
|
if (!rel.x) {
|
|
rel.flags |= XSame;
|
|
} else if (rel.x > 0 && rel.x < 256) {
|
|
rel.flags |= XShortVector|XShortPositive;
|
|
point_array_size++;
|
|
} else if (rel.x < 0 && rel.x > -256) {
|
|
rel.flags |= XShortVector;
|
|
rel.x = -rel.x;
|
|
point_array_size++;
|
|
} else {
|
|
point_array_size += 2;
|
|
}
|
|
if (!rel.y) {
|
|
rel.flags |= YSame;
|
|
} else if (rel.y > 0 && rel.y < 256) {
|
|
rel.flags |= YShortVector|YShortPositive;
|
|
point_array_size++;
|
|
} else if (rel.y < 0 && rel.y > -256) {
|
|
rel.flags |= YShortVector;
|
|
rel.y = -rel.y;
|
|
point_array_size++;
|
|
} else {
|
|
point_array_size += 2;
|
|
}
|
|
(*points)[i] = rel;
|
|
// #define toString(x) ((rel.flags & x) ? #x : "")
|
|
// qDebug() << " " << QPoint(rel.x, rel.y) << "flags="
|
|
// << toString(OnCurve) << toString(XShortVector)
|
|
// << (rel.flags & XShortVector ? toString(XShortPositive) : toString(XSame))
|
|
// << toString(YShortVector)
|
|
// << (rel.flags & YShortVector ? toString(YShortPositive) : toString(YSame));
|
|
|
|
prev_x = x;
|
|
prev_y = y;
|
|
}
|
|
return point_array_size;
|
|
}
|
|
|
|
static void getGlyphData(QTtfGlyph *glyph, const QVector<TTF_POINT> &points, const QVector<int> &endPoints, int point_array_size)
|
|
{
|
|
const int max_size = 5*sizeof(qint16) // header
|
|
+ endPoints.size()*sizeof(quint16) // end points of contours
|
|
+ sizeof(quint16) // instruction length == 0
|
|
+ points.size()*(1) // flags
|
|
+ point_array_size; // coordinates
|
|
|
|
glyph->data.resize(max_size);
|
|
|
|
QTtfStream s(glyph->data);
|
|
s << qint16(endPoints.size())
|
|
<< glyph->xMin << glyph->yMin << glyph->xMax << glyph->yMax;
|
|
|
|
for (int i = 0; i < endPoints.size(); ++i)
|
|
s << quint16(endPoints.at(i));
|
|
s << quint16(0); // instruction length
|
|
|
|
// emit flags
|
|
for (int i = 0; i < points.size(); ++i)
|
|
s << quint8(points.at(i).flags);
|
|
// emit points
|
|
for (int i = 0; i < points.size(); ++i) {
|
|
quint8 flags = points.at(i).flags;
|
|
qint16 x = points.at(i).x;
|
|
|
|
if (flags & XShortVector)
|
|
s << quint8(x);
|
|
else if (!(flags & XSame))
|
|
s << qint16(x);
|
|
}
|
|
for (int i = 0; i < points.size(); ++i) {
|
|
quint8 flags = points.at(i).flags;
|
|
qint16 y = points.at(i).y;
|
|
|
|
if (flags & YShortVector)
|
|
s << quint8(y);
|
|
else if (!(flags & YSame))
|
|
s << qint16(y);
|
|
}
|
|
|
|
// qDebug() << "offset=" << s.offset() << "max_size=" << max_size << "point_array_size=" << point_array_size;
|
|
Q_ASSERT(s.offset() == max_size);
|
|
|
|
glyph->numContours = endPoints.size();
|
|
glyph->numPoints = points.size();
|
|
}
|
|
|
|
static QTtfGlyph generateGlyph(int index, const QPainterPath &path, qreal advance, qreal lsb, qreal ppem)
|
|
{
|
|
QVector<TTF_POINT> points;
|
|
QVector<int> endPoints;
|
|
QTtfGlyph glyph;
|
|
glyph.index = index;
|
|
glyph.advanceWidth = qRound(advance * 2048. / ppem);
|
|
glyph.lsb = qRound(lsb * 2048. / ppem);
|
|
|
|
if (path.isEmpty()) {
|
|
//qDebug("glyph %d is empty", index);
|
|
lsb = 0;
|
|
glyph.xMin = glyph.xMax = glyph.yMin = glyph.yMax = 0;
|
|
glyph.numContours = 0;
|
|
glyph.numPoints = 0;
|
|
return glyph;
|
|
}
|
|
|
|
convertPath(path, &points, &endPoints, ppem);
|
|
|
|
// qDebug() << "number of contours=" << endPoints.size();
|
|
// for (int i = 0; i < points.size(); ++i)
|
|
// qDebug() << " point[" << i << "] = " << QPoint(points.at(i).x, points.at(i).y) << " flags=" << points.at(i).flags;
|
|
// qDebug("endPoints:");
|
|
// for (int i = 0; i < endPoints.size(); ++i)
|
|
// qDebug() << endPoints.at(i);
|
|
|
|
getBounds(points, &glyph.xMin, &glyph.xMax, &glyph.yMin, &glyph.yMax);
|
|
int point_array_size = convertToRelative(&points);
|
|
getGlyphData(&glyph, points, endPoints, point_array_size);
|
|
return glyph;
|
|
}
|
|
|
|
static bool operator <(const QTtfGlyph &g1, const QTtfGlyph &g2)
|
|
{
|
|
return g1.index < g2.index;
|
|
}
|
|
|
|
static QVector<QTtfTable> generateGlyphTables(qttf_font_tables &tables, const QVector<QTtfGlyph> &_glyphs)
|
|
{
|
|
const int max_size_small = 65536*2;
|
|
QVector<QTtfGlyph> glyphs = _glyphs;
|
|
std::sort(glyphs.begin(), glyphs.end());
|
|
|
|
Q_ASSERT(tables.maxp.numGlyphs == glyphs.at(glyphs.size()-1).index + 1);
|
|
int nGlyphs = tables.maxp.numGlyphs;
|
|
|
|
int glyf_size = 0;
|
|
for (int i = 0; i < glyphs.size(); ++i)
|
|
glyf_size += (glyphs.at(i).data.size() + 3) & ~3;
|
|
|
|
tables.head.indexToLocFormat = glyf_size < max_size_small ? 0 : 1;
|
|
tables.hhea.numberOfHMetrics = nGlyphs;
|
|
|
|
QTtfTable glyf;
|
|
glyf.tag = MAKE_TAG('g', 'l', 'y', 'f');
|
|
|
|
QTtfTable loca;
|
|
loca.tag = MAKE_TAG('l', 'o', 'c', 'a');
|
|
loca.data.resize(glyf_size < max_size_small ? (nGlyphs+1)*sizeof(quint16) : (nGlyphs+1)*sizeof(quint32));
|
|
QTtfStream ls(loca.data);
|
|
|
|
QTtfTable hmtx;
|
|
hmtx.tag = MAKE_TAG('h', 'm', 't', 'x');
|
|
hmtx.data.resize(nGlyphs*4);
|
|
QTtfStream hs(hmtx.data);
|
|
|
|
int pos = 0;
|
|
for (int i = 0; i < nGlyphs; ++i) {
|
|
int gpos = glyf.data.size();
|
|
quint16 advance = 0;
|
|
qint16 lsb = 0;
|
|
|
|
if (glyphs[pos].index == i) {
|
|
// emit glyph
|
|
// qDebug("emitting glyph %d: size=%d", i, glyphs.at(i).data.size());
|
|
glyf.data += glyphs.at(pos).data;
|
|
while (glyf.data.size() & 1)
|
|
glyf.data.append('\0');
|
|
advance = glyphs.at(pos).advanceWidth;
|
|
lsb = glyphs.at(pos).lsb;
|
|
++pos;
|
|
}
|
|
if (glyf_size < max_size_small) {
|
|
// use short loca format
|
|
ls << quint16(gpos>>1);
|
|
} else {
|
|
// use long loca format
|
|
ls << quint32(gpos);
|
|
}
|
|
hs << advance
|
|
<< lsb;
|
|
}
|
|
if (glyf_size < max_size_small) {
|
|
// use short loca format
|
|
ls << quint16(glyf.data.size()>>1);
|
|
} else {
|
|
// use long loca format
|
|
ls << quint32(glyf.data.size());
|
|
}
|
|
|
|
Q_ASSERT(loca.data.size() == ls.offset());
|
|
Q_ASSERT(hmtx.data.size() == hs.offset());
|
|
|
|
QVector<QTtfTable> list;
|
|
list.reserve(3);
|
|
list.append(glyf);
|
|
list.append(loca);
|
|
list.append(hmtx);
|
|
return list;
|
|
}
|
|
|
|
static bool operator <(const QTtfTable &t1, const QTtfTable &t2)
|
|
{
|
|
return t1.tag < t2.tag;
|
|
}
|
|
|
|
static QByteArray bindFont(const QVector<QTtfTable>& _tables)
|
|
{
|
|
QVector<QTtfTable> tables = _tables;
|
|
|
|
std::sort(tables.begin(), tables.end());
|
|
|
|
QByteArray font;
|
|
const int header_size = sizeof(qint32) + 4*sizeof(quint16);
|
|
const int directory_size = 4*sizeof(quint32)*tables.size();
|
|
font.resize(header_size + directory_size);
|
|
|
|
int log2 = 0;
|
|
int pow = 1;
|
|
int n = tables.size() >> 1;
|
|
while (n) {
|
|
++log2;
|
|
pow <<= 1;
|
|
n >>= 1;
|
|
}
|
|
|
|
quint32 head_offset = 0;
|
|
{
|
|
QTtfStream f(font);
|
|
// Offset Table
|
|
// Type Name Description
|
|
// qint32 sfnt version 0x00010000 for version 1.0.
|
|
// quint16 numTables Number of tables.
|
|
// quint16 searchRange (Maximum power of 2 <= numTables) x 16.
|
|
// quint16 entrySelector Log2(maximum power of 2 <= numTables).
|
|
// quint16 rangeShift NumTables x 16-searchRange.
|
|
f << qint32(0x00010000)
|
|
<< quint16(tables.size())
|
|
<< quint16(16*pow)
|
|
<< quint16(log2)
|
|
<< quint16(16*(tables.size() - pow));
|
|
|
|
// Table Directory
|
|
// Type Name Description
|
|
// quint32 tag 4 -byte identifier.
|
|
// quint32 checkSum CheckSum for this table.
|
|
// quint32 offset Offset from beginning of TrueType font file.
|
|
// quint32 length Length of this table.
|
|
quint32 table_offset = header_size + directory_size;
|
|
for (int i = 0; i < tables.size(); ++i) {
|
|
const QTtfTable &t = tables.at(i);
|
|
const quint32 size = (t.data.size() + 3) & ~3;
|
|
if (t.tag == MAKE_TAG('h', 'e', 'a', 'd'))
|
|
head_offset = table_offset;
|
|
f << t.tag
|
|
<< checksum(t.data)
|
|
<< table_offset
|
|
<< t.data.size();
|
|
table_offset += size;
|
|
#define TAG(x) char(t.tag >> 24) << char((t.tag >> 16) & 0xff) << char((t.tag >> 8) & 0xff) << char(t.tag & 0xff)
|
|
//qDebug() << "table " << TAG(t.tag) << "has size " << t.data.size() << "stream at " << f.offset();
|
|
}
|
|
}
|
|
for (int i = 0; i < tables.size(); ++i) {
|
|
const QByteArray &t = tables.at(i).data;
|
|
font += t;
|
|
int s = t.size();
|
|
while (s & 3) { font += '\0'; ++s; }
|
|
}
|
|
|
|
if (!head_offset) {
|
|
qWarning("QFontSubset: Font misses 'head' table");
|
|
return QByteArray();
|
|
}
|
|
|
|
// calculate the fonts checksum and qToBigEndian into 'head's checksum_adjust
|
|
quint32 checksum_adjust = 0xB1B0AFBA - checksum(font);
|
|
qToBigEndian(checksum_adjust, font.data() + head_offset + 8);
|
|
|
|
return font;
|
|
}
|
|
|
|
|
|
/*
|
|
PDF requires the following tables:
|
|
|
|
head, hhea, loca, maxp, cvt , prep, glyf, hmtx, fpgm
|
|
|
|
This means we don't have to add a os/2, post or name table. cvt , prep and fpgm could be empty
|
|
if really required.
|
|
*/
|
|
|
|
QByteArray QFontSubset::toTruetype() const
|
|
{
|
|
qttf_font_tables font;
|
|
memset(&font, 0, sizeof(qttf_font_tables));
|
|
|
|
qreal ppem = fontEngine->fontDef.pixelSize;
|
|
#define TO_TTF(x) qRound(x * 2048. / ppem)
|
|
|
|
QFontEngine::Properties properties = fontEngine->properties();
|
|
// initialize some stuff needed in createWidthArray
|
|
emSquare = 2048;
|
|
widths.resize(nGlyphs());
|
|
|
|
// head table
|
|
font.head.font_revision = 0x00010000;
|
|
font.head.flags = (1 << 2) | (1 << 4);
|
|
font.head.created = 0; // ###
|
|
font.head.modified = 0; // ###
|
|
font.head.xMin = SHRT_MAX;
|
|
font.head.xMax = SHRT_MIN;
|
|
font.head.yMin = SHRT_MAX;
|
|
font.head.yMax = SHRT_MIN;
|
|
font.head.macStyle = (fontEngine->fontDef.weight > QFont::Normal) ? 1 : 0;
|
|
font.head.macStyle |= (fontEngine->fontDef.styleHint != QFont::StyleNormal) ? 1 : 0;
|
|
|
|
// hhea table
|
|
font.hhea.ascender = qRound(properties.ascent);
|
|
font.hhea.descender = -qRound(properties.descent);
|
|
font.hhea.lineGap = qRound(properties.leading);
|
|
font.hhea.maxAdvanceWidth = TO_TTF(fontEngine->maxCharWidth());
|
|
font.hhea.minLeftSideBearing = TO_TTF(fontEngine->minLeftBearing());
|
|
font.hhea.minRightSideBearing = TO_TTF(fontEngine->minRightBearing());
|
|
font.hhea.xMaxExtent = SHRT_MIN;
|
|
|
|
font.maxp.numGlyphs = 0;
|
|
font.maxp.maxPoints = 0;
|
|
font.maxp.maxContours = 0;
|
|
font.maxp.maxCompositePoints = 0;
|
|
font.maxp.maxCompositeContours = 0;
|
|
font.maxp.maxComponentElements = 0;
|
|
font.maxp.maxComponentDepth = 0;
|
|
const int numGlyphs = nGlyphs();
|
|
font.maxp.numGlyphs = numGlyphs;
|
|
QVector<QTtfGlyph> glyphs;
|
|
glyphs.reserve(numGlyphs);
|
|
|
|
uint sumAdvances = 0;
|
|
for (int i = 0; i < numGlyphs; ++i) {
|
|
glyph_t g = glyph_indices.at(i);
|
|
QPainterPath path;
|
|
glyph_metrics_t metric;
|
|
fontEngine->getUnscaledGlyph(g, &path, &metric);
|
|
if (noEmbed) {
|
|
path = QPainterPath();
|
|
if (g == 0)
|
|
path.addRect(QRectF(0, 0, 1000, 1000));
|
|
}
|
|
QTtfGlyph glyph = generateGlyph(i, path, metric.xoff.toReal(), metric.x.toReal(), properties.emSquare.toReal());
|
|
|
|
font.head.xMin = qMin(font.head.xMin, glyph.xMin);
|
|
font.head.xMax = qMax(font.head.xMax, glyph.xMax);
|
|
font.head.yMin = qMin(font.head.yMin, glyph.yMin);
|
|
font.head.yMax = qMax(font.head.yMax, glyph.yMax);
|
|
|
|
font.hhea.xMaxExtent = qMax(font.hhea.xMaxExtent, (qint16)(glyph.lsb + glyph.xMax - glyph.xMin));
|
|
|
|
font.maxp.maxPoints = qMax(font.maxp.maxPoints, glyph.numPoints);
|
|
font.maxp.maxContours = qMax(font.maxp.maxContours, glyph.numContours);
|
|
|
|
if (glyph.xMax > glyph.xMin)
|
|
sumAdvances += glyph.xMax - glyph.xMin;
|
|
|
|
// qDebug("adding glyph %d size=%d", glyph.index, glyph.data.size());
|
|
glyphs.append(glyph);
|
|
widths[i] = glyph.advanceWidth;
|
|
}
|
|
|
|
|
|
QVector<QTtfTable> tables = generateGlyphTables(font, glyphs);
|
|
tables.append(generateHead(font.head));
|
|
tables.append(generateHhea(font.hhea));
|
|
tables.append(generateMaxp(font.maxp));
|
|
// name
|
|
QTtfTable name_table;
|
|
name_table.tag = MAKE_TAG('n', 'a', 'm', 'e');
|
|
if (!noEmbed)
|
|
name_table.data = fontEngine->getSfntTable(name_table.tag);
|
|
if (name_table.data.isEmpty()) {
|
|
qttf_name_table name;
|
|
if (noEmbed)
|
|
name.copyright = QLatin1String("Fake font");
|
|
else
|
|
name.copyright = QLatin1String(properties.copyright);
|
|
name.family = fontEngine->fontDef.family;
|
|
name.subfamily = QLatin1String("Regular"); // ######
|
|
name.postscript_name = QLatin1String(properties.postscriptName);
|
|
name_table = generateName(name);
|
|
}
|
|
tables.append(name_table);
|
|
|
|
if (!noEmbed) {
|
|
QTtfTable os2;
|
|
os2.tag = MAKE_TAG('O', 'S', '/', '2');
|
|
os2.data = fontEngine->getSfntTable(os2.tag);
|
|
if (!os2.data.isEmpty())
|
|
tables.append(os2);
|
|
}
|
|
|
|
return bindFont(tables);
|
|
}
|
|
|
|
QT_END_NAMESPACE
|