1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
|
// Copyright 2017 PDFium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <memory>
#include <utility>
#include "core/fpdfapi/cpdf_modulemgr.h"
#include "core/fpdfapi/font/cpdf_font.h"
#include "core/fpdfapi/font/cpdf_type1font.h"
#include "core/fpdfapi/page/cpdf_textobject.h"
#include "core/fpdfapi/parser/cpdf_array.h"
#include "core/fpdfapi/parser/cpdf_dictionary.h"
#include "core/fpdfapi/parser/cpdf_document.h"
#include "core/fpdfapi/parser/cpdf_name.h"
#include "core/fpdfapi/parser/cpdf_number.h"
#include "core/fpdfapi/parser/cpdf_reference.h"
#include "core/fpdfapi/parser/cpdf_stream.h"
#include "core/fxge/cfx_fontmgr.h"
#include "core/fxge/fx_font.h"
#include "fpdfsdk/fsdk_define.h"
#include "public/fpdf_edit.h"
namespace {
CPDF_Dictionary* LoadFontDesc(CPDF_Document* pDoc,
const CFX_ByteString& font_name,
CFX_Font* pFont,
const uint8_t* data,
uint32_t size,
int font_type) {
CPDF_Dictionary* fontDesc = pDoc->NewIndirect<CPDF_Dictionary>();
fontDesc->SetNewFor<CPDF_Name>("Type", "FontDescriptor");
fontDesc->SetNewFor<CPDF_Name>("FontName", font_name);
int flags = 0;
if (FXFT_Is_Face_fixedwidth(pFont->GetFace()))
flags |= FXFONT_FIXED_PITCH;
if (font_name.Find("Serif") > -1)
flags |= FXFONT_SERIF;
if (FXFT_Is_Face_Italic(pFont->GetFace()))
flags |= FXFONT_ITALIC;
if (FXFT_Is_Face_Bold(pFont->GetFace()))
flags |= FXFONT_BOLD;
// TODO(npm): How do I know if a font is symbolic, script, allcap, smallcap
flags |= FXFONT_NONSYMBOLIC;
fontDesc->SetNewFor<CPDF_Number>("Flags", flags);
FX_RECT bbox;
pFont->GetBBox(bbox);
auto pBBox = pdfium::MakeUnique<CPDF_Array>();
pBBox->AddNew<CPDF_Number>(bbox.left);
pBBox->AddNew<CPDF_Number>(bbox.bottom);
pBBox->AddNew<CPDF_Number>(bbox.right);
pBBox->AddNew<CPDF_Number>(bbox.top);
fontDesc->SetFor("FontBBox", std::move(pBBox));
// TODO(npm): calculate italic angle correctly
fontDesc->SetNewFor<CPDF_Number>("ItalicAngle", pFont->IsItalic() ? -12 : 0);
fontDesc->SetNewFor<CPDF_Number>("Ascent", pFont->GetAscent());
fontDesc->SetNewFor<CPDF_Number>("Descent", pFont->GetDescent());
// TODO(npm): calculate the capheight, stemV correctly
fontDesc->SetNewFor<CPDF_Number>("CapHeight", pFont->GetAscent());
fontDesc->SetNewFor<CPDF_Number>("StemV", pFont->IsBold() ? 120 : 70);
CPDF_Stream* pStream = pDoc->NewIndirect<CPDF_Stream>();
pStream->SetData(data, size);
CFX_ByteString fontFile =
font_type == FPDF_FONT_TYPE1 ? "FontFile" : "FontFile2";
fontDesc->SetNewFor<CPDF_Reference>(fontFile, pDoc, pStream->GetObjNum());
return fontDesc;
}
void* LoadSimpleFont(CPDF_Document* pDoc,
std::unique_ptr<CFX_Font> pFont,
const uint8_t* data,
uint32_t size,
int font_type) {
CPDF_Dictionary* fontDict = pDoc->NewIndirect<CPDF_Dictionary>();
fontDict->SetNewFor<CPDF_Name>("Type", "Font");
fontDict->SetNewFor<CPDF_Name>(
"Subtype", font_type == FPDF_FONT_TYPE1 ? "Type1" : "TrueType");
CFX_ByteString name = pFont->GetFaceName();
if (name.IsEmpty())
name = "Unnamed";
fontDict->SetNewFor<CPDF_Name>("BaseFont", name);
uint32_t glyphIndex;
int currentChar = FXFT_Get_First_Char(pFont->GetFace(), &glyphIndex);
fontDict->SetNewFor<CPDF_Number>("FirstChar", currentChar);
CPDF_Array* widthsArray = pDoc->NewIndirect<CPDF_Array>();
while (true) {
int width = pFont->GetGlyphWidth(glyphIndex);
widthsArray->AddNew<CPDF_Number>(width);
int nextChar =
FXFT_Get_Next_Char(pFont->GetFace(), currentChar, &glyphIndex);
// Simple fonts have 1-byte charcodes only.
if (nextChar > 0xff || glyphIndex == 0)
break;
for (int i = currentChar + 1; i < nextChar; i++)
widthsArray->AddNew<CPDF_Number>(0);
currentChar = nextChar;
}
fontDict->SetNewFor<CPDF_Number>("LastChar", currentChar);
fontDict->SetNewFor<CPDF_Reference>("Widths", pDoc, widthsArray->GetObjNum());
CPDF_Dictionary* fontDesc =
LoadFontDesc(pDoc, name, pFont.get(), data, size, font_type);
fontDict->SetNewFor<CPDF_Reference>("FontDescriptor", pDoc,
fontDesc->GetObjNum());
return pDoc->LoadFont(fontDict);
}
void* LoadCompositeFont(CPDF_Document* pDoc,
std::unique_ptr<CFX_Font> pFont,
const uint8_t* data,
uint32_t size,
int font_type) {
CPDF_Dictionary* fontDict = pDoc->NewIndirect<CPDF_Dictionary>();
fontDict->SetNewFor<CPDF_Name>("Type", "Font");
fontDict->SetNewFor<CPDF_Name>("Subtype", "Type0");
// TODO(npm): Get the correct encoding, if it's not identity.
CFX_ByteString encoding = "Identity-H";
fontDict->SetNewFor<CPDF_Name>("Encoding", encoding);
CFX_ByteString name = pFont->GetFaceName();
if (name.IsEmpty())
name = "Unnamed";
fontDict->SetNewFor<CPDF_Name>(
"BaseFont", font_type == FPDF_FONT_TYPE1 ? name + "-" + encoding : name);
CPDF_Dictionary* pCIDFont = pDoc->NewIndirect<CPDF_Dictionary>();
pCIDFont->SetNewFor<CPDF_Name>("Type", "Font");
pCIDFont->SetNewFor<CPDF_Name>("Subtype", font_type == FPDF_FONT_TYPE1
? "CIDFontType0"
: "CIDFontType2");
pCIDFont->SetNewFor<CPDF_Name>("BaseFont", name);
// TODO(npm): Maybe use FT_Get_CID_Registry_Ordering_Supplement to get the
// CIDSystemInfo
CPDF_Dictionary* pCIDSystemInfo = pDoc->NewIndirect<CPDF_Dictionary>();
pCIDSystemInfo->SetNewFor<CPDF_Name>("Registry", "Adobe");
pCIDSystemInfo->SetNewFor<CPDF_Name>("Ordering", "Identity");
pCIDSystemInfo->SetNewFor<CPDF_Number>("Supplement", 0);
pCIDFont->SetNewFor<CPDF_Reference>("CIDSystemInfo", pDoc,
pCIDSystemInfo->GetObjNum());
CPDF_Dictionary* fontDesc =
LoadFontDesc(pDoc, name, pFont.get(), data, size, font_type);
pCIDFont->SetNewFor<CPDF_Reference>("FontDescriptor", pDoc,
fontDesc->GetObjNum());
uint32_t glyphIndex;
int currentChar = FXFT_Get_First_Char(pFont->GetFace(), &glyphIndex);
CPDF_Array* widthsArray = pDoc->NewIndirect<CPDF_Array>();
while (true) {
int width = pFont->GetGlyphWidth(glyphIndex);
int nextChar =
FXFT_Get_Next_Char(pFont->GetFace(), currentChar, &glyphIndex);
if (glyphIndex == 0) {
// Only one char left, use format c [w]
auto oneW = pdfium::MakeUnique<CPDF_Array>();
oneW->AddNew<CPDF_Number>(width);
widthsArray->AddNew<CPDF_Number>(currentChar);
widthsArray->Add(std::move(oneW));
break;
}
int nextWidth = pFont->GetGlyphWidth(glyphIndex);
if (nextChar == currentChar + 1 && nextWidth == width) {
// The array can have a group c_first c_last w: all CIDs in the range from
// c_first to c_last will have width w
widthsArray->AddNew<CPDF_Number>(currentChar);
currentChar = nextChar;
while (true) {
nextChar =
FXFT_Get_Next_Char(pFont->GetFace(), currentChar, &glyphIndex);
if (glyphIndex == 0)
break;
nextWidth = pFont->GetGlyphWidth(glyphIndex);
if (nextChar != currentChar + 1 || nextWidth != width)
break;
currentChar = nextChar;
}
widthsArray->AddNew<CPDF_Number>(currentChar);
widthsArray->AddNew<CPDF_Number>(width);
} else {
// Otherwise we can have a group of the form c [w1 w2 ...]: c has width
// w1, c+1 has width w2, etc.
widthsArray->AddNew<CPDF_Number>(currentChar);
auto curWidthArray = pdfium::MakeUnique<CPDF_Array>();
curWidthArray->AddNew<CPDF_Number>(width);
while (nextChar == currentChar + 1) {
curWidthArray->AddNew<CPDF_Number>(nextWidth);
currentChar = nextChar;
nextChar =
FXFT_Get_Next_Char(pFont->GetFace(), currentChar, &glyphIndex);
if (glyphIndex == 0)
break;
nextWidth = pFont->GetGlyphWidth(glyphIndex);
}
widthsArray->Add(std::move(curWidthArray));
}
if (glyphIndex == 0)
break;
currentChar = nextChar;
}
pCIDFont->SetNewFor<CPDF_Reference>("W", pDoc, widthsArray->GetObjNum());
// TODO(npm): Support vertical writing
auto pDescendant = pdfium::MakeUnique<CPDF_Array>();
pDescendant->AddNew<CPDF_Reference>(pDoc, pCIDFont->GetObjNum());
fontDict->SetFor("DescendantFonts", std::move(pDescendant));
// TODO(npm): do we need a ToUnicode?
return pDoc->LoadFont(fontDict);
}
} // namespace
DLLEXPORT FPDF_PAGEOBJECT STDCALL FPDFPageObj_NewTextObj(FPDF_DOCUMENT document,
FPDF_BYTESTRING font,
float font_size) {
CPDF_Document* pDoc = CPDFDocumentFromFPDFDocument(document);
if (!pDoc)
return nullptr;
CPDF_Font* pFont = CPDF_Font::GetStockFont(pDoc, CFX_ByteStringC(font));
if (!pFont)
return nullptr;
CPDF_TextObject* pTextObj = new CPDF_TextObject;
pTextObj->m_TextState.SetFont(pFont);
pTextObj->m_TextState.SetFontSize(font_size);
pTextObj->DefaultStates();
return pTextObj;
}
DLLEXPORT FPDF_BOOL STDCALL FPDFText_SetText(FPDF_PAGEOBJECT text_object,
FPDF_BYTESTRING text) {
if (!text_object)
return false;
auto* pTextObj = reinterpret_cast<CPDF_TextObject*>(text_object);
pTextObj->SetText(CFX_ByteString(text));
return true;
}
DLLEXPORT FPDF_FONT STDCALL FPDFText_LoadFont(FPDF_DOCUMENT document,
const uint8_t* data,
uint32_t size,
int font_type,
FPDF_BOOL cid) {
CPDF_Document* pDoc = CPDFDocumentFromFPDFDocument(document);
if (!pDoc || !data || size == 0 ||
(font_type != FPDF_FONT_TYPE1 && font_type != FPDF_FONT_TRUETYPE)) {
return nullptr;
}
auto pFont = pdfium::MakeUnique<CFX_Font>();
// TODO(npm): Maybe use FT_Get_X11_Font_Format to check format? Otherwise, we
// are allowing giving any font that can be loaded on freetype and setting it
// as any font type.
if (!pFont->LoadEmbedded(data, size))
return nullptr;
return cid ? LoadCompositeFont(pDoc, std::move(pFont), data, size, font_type)
: LoadSimpleFont(pDoc, std::move(pFont), data, size, font_type);
}
|
