1 // Copyright 2017 PDFium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include <algorithm>
6 #include <limits>
7 #include <map>
8 #include <memory>
9 #include <utility>
10 #include <vector>
11
12 #include "core/fpdfapi/font/cpdf_font.h"
13 #include "core/fpdfapi/font/cpdf_type1font.h"
14 #include "core/fpdfapi/page/cpdf_docpagedata.h"
15 #include "core/fpdfapi/page/cpdf_textobject.h"
16 #include "core/fpdfapi/page/cpdf_textstate.h"
17 #include "core/fpdfapi/parser/cpdf_array.h"
18 #include "core/fpdfapi/parser/cpdf_dictionary.h"
19 #include "core/fpdfapi/parser/cpdf_document.h"
20 #include "core/fpdfapi/parser/cpdf_name.h"
21 #include "core/fpdfapi/parser/cpdf_number.h"
22 #include "core/fpdfapi/parser/cpdf_reference.h"
23 #include "core/fpdfapi/parser/cpdf_stream.h"
24 #include "core/fpdfapi/parser/cpdf_string.h"
25 #include "core/fpdftext/cpdf_textpage.h"
26 #include "core/fxcrt/fx_extension.h"
27 #include "core/fxge/cfx_fontmgr.h"
28 #include "core/fxge/fx_font.h"
29 #include "fpdfsdk/cpdfsdk_helpers.h"
30 #include "public/fpdf_edit.h"
31 #include "third_party/base/ptr_util.h"
32
33 // These checks are here because core/ and public/ cannot depend on each other.
34 static_assert(static_cast<int>(TextRenderingMode::MODE_UNKNOWN) ==
35 FPDF_TEXTRENDERMODE_UNKNOWN,
36 "TextRenderingMode::MODE_UNKNOWN value mismatch");
37 static_assert(static_cast<int>(TextRenderingMode::MODE_FILL) ==
38 FPDF_TEXTRENDERMODE_FILL,
39 "TextRenderingMode::MODE_FILL value mismatch");
40 static_assert(static_cast<int>(TextRenderingMode::MODE_STROKE) ==
41 FPDF_TEXTRENDERMODE_STROKE,
42 "TextRenderingMode::MODE_STROKE value mismatch");
43 static_assert(static_cast<int>(TextRenderingMode::MODE_FILL_STROKE) ==
44 FPDF_TEXTRENDERMODE_FILL_STROKE,
45 "TextRenderingMode::MODE_FILL_STROKE value mismatch");
46 static_assert(static_cast<int>(TextRenderingMode::MODE_INVISIBLE) ==
47 FPDF_TEXTRENDERMODE_INVISIBLE,
48 "TextRenderingMode::MODE_INVISIBLE value mismatch");
49 static_assert(static_cast<int>(TextRenderingMode::MODE_FILL_CLIP) ==
50 FPDF_TEXTRENDERMODE_FILL_CLIP,
51 "TextRenderingMode::MODE_FILL_CLIP value mismatch");
52 static_assert(static_cast<int>(TextRenderingMode::MODE_STROKE_CLIP) ==
53 FPDF_TEXTRENDERMODE_STROKE_CLIP,
54 "TextRenderingMode::MODE_STROKE_CLIP value mismatch");
55 static_assert(static_cast<int>(TextRenderingMode::MODE_FILL_STROKE_CLIP) ==
56 FPDF_TEXTRENDERMODE_FILL_STROKE_CLIP,
57 "TextRenderingMode::MODE_FILL_STROKE_CLIP value mismatch");
58 static_assert(static_cast<int>(TextRenderingMode::MODE_CLIP) ==
59 FPDF_TEXTRENDERMODE_CLIP,
60 "TextRenderingMode::MODE_CLIP value mismatch");
61 static_assert(static_cast<int>(TextRenderingMode::MODE_LAST) ==
62 FPDF_TEXTRENDERMODE_LAST,
63 "TextRenderingMode::MODE_LAST value mismatch");
64
65 namespace {
66
LoadFontDesc(CPDF_Document * pDoc,const ByteString & font_name,CFX_Font * pFont,pdfium::span<const uint8_t> span,int font_type)67 CPDF_Dictionary* LoadFontDesc(CPDF_Document* pDoc,
68 const ByteString& font_name,
69 CFX_Font* pFont,
70 pdfium::span<const uint8_t> span,
71 int font_type) {
72 CPDF_Dictionary* pFontDesc = pDoc->NewIndirect<CPDF_Dictionary>();
73 pFontDesc->SetNewFor<CPDF_Name>("Type", "FontDescriptor");
74 pFontDesc->SetNewFor<CPDF_Name>("FontName", font_name);
75 int flags = 0;
76 if (FXFT_Is_Face_fixedwidth(pFont->GetFaceRec()))
77 flags |= FXFONT_FIXED_PITCH;
78 if (font_name.Contains("Serif"))
79 flags |= FXFONT_SERIF;
80 if (FXFT_Is_Face_Italic(pFont->GetFaceRec()))
81 flags |= FXFONT_ITALIC;
82 if (FXFT_Is_Face_Bold(pFont->GetFaceRec()))
83 flags |= FXFONT_FORCE_BOLD;
84
85 // TODO(npm): How do I know if a font is symbolic, script, allcap, smallcap
86 flags |= FXFONT_NONSYMBOLIC;
87
88 pFontDesc->SetNewFor<CPDF_Number>("Flags", flags);
89 FX_RECT bbox;
90 pFont->GetBBox(&bbox);
91 pFontDesc->SetRectFor("FontBBox", CFX_FloatRect(bbox));
92
93 // TODO(npm): calculate italic angle correctly
94 pFontDesc->SetNewFor<CPDF_Number>("ItalicAngle", pFont->IsItalic() ? -12 : 0);
95
96 pFontDesc->SetNewFor<CPDF_Number>("Ascent", pFont->GetAscent());
97 pFontDesc->SetNewFor<CPDF_Number>("Descent", pFont->GetDescent());
98
99 // TODO(npm): calculate the capheight, stemV correctly
100 pFontDesc->SetNewFor<CPDF_Number>("CapHeight", pFont->GetAscent());
101 pFontDesc->SetNewFor<CPDF_Number>("StemV", pFont->IsBold() ? 120 : 70);
102
103 CPDF_Stream* pStream = pDoc->NewIndirect<CPDF_Stream>();
104 pStream->SetData(span);
105 // TODO(npm): Lengths for Type1 fonts.
106 if (font_type == FPDF_FONT_TRUETYPE) {
107 pStream->GetDict()->SetNewFor<CPDF_Number>("Length1",
108 static_cast<int>(span.size()));
109 }
110 ByteString fontFile = font_type == FPDF_FONT_TYPE1 ? "FontFile" : "FontFile2";
111 pFontDesc->SetNewFor<CPDF_Reference>(fontFile, pDoc, pStream->GetObjNum());
112 return pFontDesc;
113 }
114
115 const char ToUnicodeStart[] =
116 "/CIDInit /ProcSet findresource begin\n"
117 "12 dict begin\n"
118 "begincmap\n"
119 "/CIDSystemInfo\n"
120 "<</Registry (Adobe)\n"
121 "/Ordering (Identity)\n"
122 "/Supplement 0\n"
123 ">> def\n"
124 "/CMapName /Adobe-Identity-H def\n"
125 "CMapType 2 def\n"
126 "1 begincodespacerange\n"
127 "<0000> <FFFFF>\n"
128 "endcodespacerange\n";
129
130 const char ToUnicodeEnd[] =
131 "endcmap\n"
132 "CMapName currentdict /CMap defineresource pop\n"
133 "end\n"
134 "end\n";
135
AddCharcode(std::ostringstream * pBuffer,uint32_t number)136 void AddCharcode(std::ostringstream* pBuffer, uint32_t number) {
137 ASSERT(number <= 0xFFFF);
138 *pBuffer << "<";
139 char ans[4];
140 FXSYS_IntToFourHexChars(number, ans);
141 for (size_t i = 0; i < 4; ++i)
142 *pBuffer << ans[i];
143 *pBuffer << ">";
144 }
145
146 // PDF spec 1.7 Section 5.9.2: "Unicode character sequences as expressed in
147 // UTF-16BE encoding." See https://en.wikipedia.org/wiki/UTF-16#Description
AddUnicode(std::ostringstream * pBuffer,uint32_t unicode)148 void AddUnicode(std::ostringstream* pBuffer, uint32_t unicode) {
149 if (unicode >= 0xD800 && unicode <= 0xDFFF)
150 unicode = 0;
151
152 char ans[8];
153 *pBuffer << "<";
154 size_t numChars = FXSYS_ToUTF16BE(unicode, ans);
155 for (size_t i = 0; i < numChars; ++i)
156 *pBuffer << ans[i];
157 *pBuffer << ">";
158 }
159
160 // Loads the charcode to unicode mapping into a stream
LoadUnicode(CPDF_Document * pDoc,const std::map<uint32_t,uint32_t> & to_unicode)161 CPDF_Stream* LoadUnicode(CPDF_Document* pDoc,
162 const std::map<uint32_t, uint32_t>& to_unicode) {
163 // A map charcode->unicode
164 std::map<uint32_t, uint32_t> char_to_uni;
165 // A map <char_start, char_end> to vector v of unicode characters of size (end
166 // - start + 1). This abbreviates: start->v[0], start+1->v[1], etc. PDF spec
167 // 1.7 Section 5.9.2 says that only the last byte of the unicode may change.
168 std::map<std::pair<uint32_t, uint32_t>, std::vector<uint32_t>>
169 map_range_vector;
170 // A map <start, end> -> unicode
171 // This abbreviates: start->unicode, start+1->unicode+1, etc.
172 // PDF spec 1.7 Section 5.9.2 says that only the last byte of the unicode may
173 // change.
174 std::map<std::pair<uint32_t, uint32_t>, uint32_t> map_range;
175
176 // Calculate the maps
177 for (auto iter = to_unicode.begin(); iter != to_unicode.end(); ++iter) {
178 uint32_t firstCharcode = iter->first;
179 uint32_t firstUnicode = iter->second;
180 if (std::next(iter) == to_unicode.end() ||
181 firstCharcode + 1 != std::next(iter)->first) {
182 char_to_uni[firstCharcode] = firstUnicode;
183 continue;
184 }
185 ++iter;
186 uint32_t curCharcode = iter->first;
187 uint32_t curUnicode = iter->second;
188 if (curCharcode % 256 == 0) {
189 char_to_uni[firstCharcode] = firstUnicode;
190 char_to_uni[curCharcode] = curUnicode;
191 continue;
192 }
193 const size_t maxExtra = 255 - (curCharcode % 256);
194 auto next_it = std::next(iter);
195 if (firstUnicode + 1 != curUnicode) {
196 // Consecutive charcodes mapping to non-consecutive unicodes
197 std::vector<uint32_t> unicodes;
198 unicodes.push_back(firstUnicode);
199 unicodes.push_back(curUnicode);
200 for (size_t i = 0; i < maxExtra; ++i) {
201 if (next_it == to_unicode.end() || curCharcode + 1 != next_it->first)
202 break;
203 ++iter;
204 ++curCharcode;
205 unicodes.push_back(iter->second);
206 next_it = std::next(iter);
207 }
208 ASSERT(iter->first - firstCharcode + 1 == unicodes.size());
209 map_range_vector[std::make_pair(firstCharcode, iter->first)] = unicodes;
210 continue;
211 }
212 // Consecutive charcodes mapping to consecutive unicodes
213 for (size_t i = 0; i < maxExtra; ++i) {
214 if (next_it == to_unicode.end() || curCharcode + 1 != next_it->first ||
215 curUnicode + 1 != next_it->second) {
216 break;
217 }
218 ++iter;
219 ++curCharcode;
220 ++curUnicode;
221 next_it = std::next(iter);
222 }
223 map_range[std::make_pair(firstCharcode, curCharcode)] = firstUnicode;
224 }
225 std::ostringstream buffer;
226 buffer << ToUnicodeStart;
227 // Add maps to buffer
228 buffer << static_cast<uint32_t>(char_to_uni.size()) << " beginbfchar\n";
229 for (const auto& iter : char_to_uni) {
230 AddCharcode(&buffer, iter.first);
231 buffer << " ";
232 AddUnicode(&buffer, iter.second);
233 buffer << "\n";
234 }
235 buffer << "endbfchar\n"
236 << static_cast<uint32_t>(map_range_vector.size() + map_range.size())
237 << " beginbfrange\n";
238 for (const auto& iter : map_range_vector) {
239 const std::pair<uint32_t, uint32_t>& charcodeRange = iter.first;
240 AddCharcode(&buffer, charcodeRange.first);
241 buffer << " ";
242 AddCharcode(&buffer, charcodeRange.second);
243 buffer << " [";
244 const std::vector<uint32_t>& unicodes = iter.second;
245 for (size_t i = 0; i < unicodes.size(); ++i) {
246 uint32_t uni = unicodes[i];
247 AddUnicode(&buffer, uni);
248 if (i != unicodes.size() - 1)
249 buffer << " ";
250 }
251 buffer << "]\n";
252 }
253 for (const auto& iter : map_range) {
254 const std::pair<uint32_t, uint32_t>& charcodeRange = iter.first;
255 AddCharcode(&buffer, charcodeRange.first);
256 buffer << " ";
257 AddCharcode(&buffer, charcodeRange.second);
258 buffer << " ";
259 AddUnicode(&buffer, iter.second);
260 buffer << "\n";
261 }
262 buffer << "endbfrange\n";
263 buffer << ToUnicodeEnd;
264 // TODO(npm): Encrypt / Compress?
265 CPDF_Stream* stream = pDoc->NewIndirect<CPDF_Stream>();
266 stream->SetDataFromStringstream(&buffer);
267 return stream;
268 }
269
LoadSimpleFont(CPDF_Document * pDoc,std::unique_ptr<CFX_Font> pFont,pdfium::span<const uint8_t> span,int font_type)270 RetainPtr<CPDF_Font> LoadSimpleFont(CPDF_Document* pDoc,
271 std::unique_ptr<CFX_Font> pFont,
272 pdfium::span<const uint8_t> span,
273 int font_type) {
274 CPDF_Dictionary* pFontDict = pDoc->NewIndirect<CPDF_Dictionary>();
275 pFontDict->SetNewFor<CPDF_Name>("Type", "Font");
276 pFontDict->SetNewFor<CPDF_Name>(
277 "Subtype", font_type == FPDF_FONT_TYPE1 ? "Type1" : "TrueType");
278 ByteString name = pFont->GetBaseFontName(font_type == FPDF_FONT_TYPE1);
279 if (name.IsEmpty())
280 name = CFX_Font::kUntitledFontName;
281 pFontDict->SetNewFor<CPDF_Name>("BaseFont", name);
282
283 uint32_t dwGlyphIndex;
284 uint32_t dwCurrentChar =
285 FT_Get_First_Char(pFont->GetFaceRec(), &dwGlyphIndex);
286 static constexpr uint32_t kMaxSimpleFontChar = 0xFF;
287 if (dwCurrentChar > kMaxSimpleFontChar || dwGlyphIndex == 0)
288 return nullptr;
289 pFontDict->SetNewFor<CPDF_Number>("FirstChar",
290 static_cast<int>(dwCurrentChar));
291 CPDF_Array* widthsArray = pDoc->NewIndirect<CPDF_Array>();
292 while (true) {
293 uint32_t width =
294 std::min(pFont->GetGlyphWidth(dwGlyphIndex),
295 static_cast<uint32_t>(std::numeric_limits<int>::max()));
296 widthsArray->AddNew<CPDF_Number>(static_cast<int>(width));
297 uint32_t nextChar =
298 FT_Get_Next_Char(pFont->GetFaceRec(), dwCurrentChar, &dwGlyphIndex);
299 // Simple fonts have 1-byte charcodes only.
300 if (nextChar > kMaxSimpleFontChar || dwGlyphIndex == 0)
301 break;
302 for (uint32_t i = dwCurrentChar + 1; i < nextChar; i++)
303 widthsArray->AddNew<CPDF_Number>(0);
304 dwCurrentChar = nextChar;
305 }
306 pFontDict->SetNewFor<CPDF_Number>("LastChar",
307 static_cast<int>(dwCurrentChar));
308 pFontDict->SetNewFor<CPDF_Reference>("Widths", pDoc,
309 widthsArray->GetObjNum());
310 CPDF_Dictionary* pFontDesc =
311 LoadFontDesc(pDoc, name, pFont.get(), span, font_type);
312
313 pFontDict->SetNewFor<CPDF_Reference>("FontDescriptor", pDoc,
314 pFontDesc->GetObjNum());
315 return CPDF_DocPageData::FromDocument(pDoc)->GetFont(pFontDict);
316 }
317
LoadCompositeFont(CPDF_Document * pDoc,std::unique_ptr<CFX_Font> pFont,pdfium::span<const uint8_t> span,int font_type)318 RetainPtr<CPDF_Font> LoadCompositeFont(CPDF_Document* pDoc,
319 std::unique_ptr<CFX_Font> pFont,
320 pdfium::span<const uint8_t> span,
321 int font_type) {
322 CPDF_Dictionary* pFontDict = pDoc->NewIndirect<CPDF_Dictionary>();
323 pFontDict->SetNewFor<CPDF_Name>("Type", "Font");
324 pFontDict->SetNewFor<CPDF_Name>("Subtype", "Type0");
325 // TODO(npm): Get the correct encoding, if it's not identity.
326 ByteString encoding = "Identity-H";
327 pFontDict->SetNewFor<CPDF_Name>("Encoding", encoding);
328 ByteString name = pFont->GetBaseFontName(font_type == FPDF_FONT_TYPE1);
329 if (name.IsEmpty())
330 name = CFX_Font::kUntitledFontName;
331 pFontDict->SetNewFor<CPDF_Name>(
332 "BaseFont", font_type == FPDF_FONT_TYPE1 ? name + "-" + encoding : name);
333
334 CPDF_Dictionary* pCIDFont = pDoc->NewIndirect<CPDF_Dictionary>();
335 pCIDFont->SetNewFor<CPDF_Name>("Type", "Font");
336 pCIDFont->SetNewFor<CPDF_Name>("Subtype", font_type == FPDF_FONT_TYPE1
337 ? "CIDFontType0"
338 : "CIDFontType2");
339 pCIDFont->SetNewFor<CPDF_Name>("BaseFont", name);
340
341 // TODO(npm): Maybe use FT_Get_CID_Registry_Ordering_Supplement to get the
342 // CIDSystemInfo
343 CPDF_Dictionary* pCIDSystemInfo = pDoc->NewIndirect<CPDF_Dictionary>();
344 pCIDSystemInfo->SetNewFor<CPDF_String>("Registry", "Adobe", false);
345 pCIDSystemInfo->SetNewFor<CPDF_String>("Ordering", "Identity", false);
346 pCIDSystemInfo->SetNewFor<CPDF_Number>("Supplement", 0);
347 pCIDFont->SetNewFor<CPDF_Reference>("CIDSystemInfo", pDoc,
348 pCIDSystemInfo->GetObjNum());
349
350 CPDF_Dictionary* pFontDesc =
351 LoadFontDesc(pDoc, name, pFont.get(), span, font_type);
352 pCIDFont->SetNewFor<CPDF_Reference>("FontDescriptor", pDoc,
353 pFontDesc->GetObjNum());
354
355 uint32_t dwGlyphIndex;
356 uint32_t dwCurrentChar =
357 FT_Get_First_Char(pFont->GetFaceRec(), &dwGlyphIndex);
358 static constexpr uint32_t kMaxUnicode = 0x10FFFF;
359 // If it doesn't have a single char, just fail
360 if (dwGlyphIndex == 0 || dwCurrentChar > kMaxUnicode)
361 return nullptr;
362
363 std::map<uint32_t, uint32_t> to_unicode;
364 std::map<uint32_t, uint32_t> widths;
365 while (true) {
366 if (dwCurrentChar > kMaxUnicode)
367 break;
368
369 if (!pdfium::ContainsKey(widths, dwGlyphIndex))
370 widths[dwGlyphIndex] = pFont->GetGlyphWidth(dwGlyphIndex);
371 to_unicode[dwGlyphIndex] = dwCurrentChar;
372 dwCurrentChar =
373 FT_Get_Next_Char(pFont->GetFaceRec(), dwCurrentChar, &dwGlyphIndex);
374 if (dwGlyphIndex == 0)
375 break;
376 }
377 CPDF_Array* widthsArray = pDoc->NewIndirect<CPDF_Array>();
378 for (auto it = widths.begin(); it != widths.end(); ++it) {
379 int ch = it->first;
380 int w = it->second;
381 if (std::next(it) == widths.end()) {
382 // Only one char left, use format c [w]
383 auto oneW = pdfium::MakeRetain<CPDF_Array>();
384 oneW->AddNew<CPDF_Number>(w);
385 widthsArray->AddNew<CPDF_Number>(ch);
386 widthsArray->Add(oneW);
387 break;
388 }
389 ++it;
390 int next_ch = it->first;
391 int next_w = it->second;
392 if (next_ch == ch + 1 && next_w == w) {
393 // The array can have a group c_first c_last w: all CIDs in the range from
394 // c_first to c_last will have width w
395 widthsArray->AddNew<CPDF_Number>(ch);
396 ch = next_ch;
397 while (true) {
398 auto next_it = std::next(it);
399 if (next_it == widths.end() || next_it->first != it->first + 1 ||
400 next_it->second != it->second) {
401 break;
402 }
403 ++it;
404 ch = it->first;
405 }
406 widthsArray->AddNew<CPDF_Number>(ch);
407 widthsArray->AddNew<CPDF_Number>(w);
408 continue;
409 }
410 // Otherwise we can have a group of the form c [w1 w2 ...]: c has width
411 // w1, c+1 has width w2, etc.
412 widthsArray->AddNew<CPDF_Number>(ch);
413 auto curWidthArray = pdfium::MakeRetain<CPDF_Array>();
414 curWidthArray->AddNew<CPDF_Number>(w);
415 curWidthArray->AddNew<CPDF_Number>(next_w);
416 while (true) {
417 auto next_it = std::next(it);
418 if (next_it == widths.end() || next_it->first != it->first + 1)
419 break;
420 ++it;
421 curWidthArray->AddNew<CPDF_Number>(static_cast<int>(it->second));
422 }
423 widthsArray->Add(curWidthArray);
424 }
425 pCIDFont->SetNewFor<CPDF_Reference>("W", pDoc, widthsArray->GetObjNum());
426
427 // TODO(npm): Support vertical writing
428
429 auto* pDescendant = pFontDict->SetNewFor<CPDF_Array>("DescendantFonts");
430 pDescendant->AddNew<CPDF_Reference>(pDoc, pCIDFont->GetObjNum());
431
432 CPDF_Stream* toUnicodeStream = LoadUnicode(pDoc, to_unicode);
433 pFontDict->SetNewFor<CPDF_Reference>("ToUnicode", pDoc,
434 toUnicodeStream->GetObjNum());
435 return CPDF_DocPageData::FromDocument(pDoc)->GetFont(pFontDict);
436 }
437
CPDFTextObjectFromFPDFPageObject(FPDF_PAGEOBJECT page_object)438 CPDF_TextObject* CPDFTextObjectFromFPDFPageObject(FPDF_PAGEOBJECT page_object) {
439 auto* obj = CPDFPageObjectFromFPDFPageObject(page_object);
440 return obj ? obj->AsText() : nullptr;
441 }
442
443 } // namespace
444
445 FPDF_EXPORT FPDF_PAGEOBJECT FPDF_CALLCONV
FPDFPageObj_NewTextObj(FPDF_DOCUMENT document,FPDF_BYTESTRING font,float font_size)446 FPDFPageObj_NewTextObj(FPDF_DOCUMENT document,
447 FPDF_BYTESTRING font,
448 float font_size) {
449 CPDF_Document* pDoc = CPDFDocumentFromFPDFDocument(document);
450 if (!pDoc)
451 return nullptr;
452
453 RetainPtr<CPDF_Font> pFont =
454 CPDF_Font::GetStockFont(pDoc, ByteStringView(font));
455 if (!pFont)
456 return nullptr;
457
458 auto pTextObj = pdfium::MakeUnique<CPDF_TextObject>();
459 pTextObj->m_TextState.SetFont(pFont);
460 pTextObj->m_TextState.SetFontSize(font_size);
461 pTextObj->DefaultStates();
462
463 // Caller takes ownership.
464 return FPDFPageObjectFromCPDFPageObject(pTextObj.release());
465 }
466
467 FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV
FPDFText_SetText(FPDF_PAGEOBJECT text_object,FPDF_WIDESTRING text)468 FPDFText_SetText(FPDF_PAGEOBJECT text_object, FPDF_WIDESTRING text) {
469 CPDF_TextObject* pTextObj = CPDFTextObjectFromFPDFPageObject(text_object);
470 if (!pTextObj)
471 return false;
472
473 WideString encodedText = WideStringFromFPDFWideString(text);
474 ByteString byteText;
475 for (wchar_t wc : encodedText) {
476 pTextObj->GetFont()->AppendChar(
477 &byteText, pTextObj->GetFont()->CharCodeFromUnicode(wc));
478 }
479 pTextObj->SetText(byteText);
480 return true;
481 }
482
FPDFText_LoadFont(FPDF_DOCUMENT document,const uint8_t * data,uint32_t size,int font_type,FPDF_BOOL cid)483 FPDF_EXPORT FPDF_FONT FPDF_CALLCONV FPDFText_LoadFont(FPDF_DOCUMENT document,
484 const uint8_t* data,
485 uint32_t size,
486 int font_type,
487 FPDF_BOOL cid) {
488 CPDF_Document* pDoc = CPDFDocumentFromFPDFDocument(document);
489 if (!pDoc || !data || size == 0 ||
490 (font_type != FPDF_FONT_TYPE1 && font_type != FPDF_FONT_TRUETYPE)) {
491 return nullptr;
492 }
493
494 auto span = pdfium::make_span(data, size);
495 auto pFont = pdfium::MakeUnique<CFX_Font>();
496
497 // TODO(npm): Maybe use FT_Get_X11_Font_Format to check format? Otherwise, we
498 // are allowing giving any font that can be loaded on freetype and setting it
499 // as any font type.
500 if (!pFont->LoadEmbedded(span, false))
501 return nullptr;
502
503 // Caller takes ownership.
504 return FPDFFontFromCPDFFont(
505 cid ? LoadCompositeFont(pDoc, std::move(pFont), span, font_type).Leak()
506 : LoadSimpleFont(pDoc, std::move(pFont), span, font_type).Leak());
507 }
508
509 FPDF_EXPORT FPDF_FONT FPDF_CALLCONV
FPDFText_LoadStandardFont(FPDF_DOCUMENT document,FPDF_BYTESTRING font)510 FPDFText_LoadStandardFont(FPDF_DOCUMENT document, FPDF_BYTESTRING font) {
511 CPDF_Document* pDoc = CPDFDocumentFromFPDFDocument(document);
512 if (!pDoc)
513 return nullptr;
514
515 // Caller takes ownership.
516 return FPDFFontFromCPDFFont(
517 CPDF_Font::GetStockFont(pDoc, ByteStringView(font)).Leak());
518 }
519
FPDFTextObj_GetMatrix(FPDF_PAGEOBJECT text,FS_MATRIX * matrix)520 FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFTextObj_GetMatrix(FPDF_PAGEOBJECT text,
521 FS_MATRIX* matrix) {
522 if (!matrix)
523 return false;
524
525 CPDF_TextObject* pTextObj = CPDFTextObjectFromFPDFPageObject(text);
526 if (!pTextObj)
527 return false;
528
529 *matrix = FSMatrixFromCFXMatrix(pTextObj->GetTextMatrix());
530 return true;
531 }
532
FPDFTextObj_GetFontSize(FPDF_PAGEOBJECT text)533 FPDF_EXPORT float FPDF_CALLCONV FPDFTextObj_GetFontSize(FPDF_PAGEOBJECT text) {
534 CPDF_TextObject* pTextObj = CPDFTextObjectFromFPDFPageObject(text);
535 return pTextObj ? pTextObj->GetFontSize() : 0.0f;
536 }
537
538 FPDF_EXPORT unsigned long FPDF_CALLCONV
FPDFTextObj_GetFontName(FPDF_PAGEOBJECT text,void * buffer,unsigned long length)539 FPDFTextObj_GetFontName(FPDF_PAGEOBJECT text,
540 void* buffer,
541 unsigned long length) {
542 CPDF_TextObject* pTextObj = CPDFTextObjectFromFPDFPageObject(text);
543 if (!pTextObj)
544 return 0;
545
546 RetainPtr<CPDF_Font> pPdfFont = pTextObj->GetFont();
547 CFX_Font* pFont = pPdfFont->GetFont();
548 ByteString name = pFont->GetFamilyName();
549 unsigned long dwStringLen = name.GetLength() + 1;
550 if (buffer && length >= dwStringLen)
551 memcpy(buffer, name.c_str(), dwStringLen);
552
553 return dwStringLen;
554 }
555
556 FPDF_EXPORT unsigned long FPDF_CALLCONV
FPDFTextObj_GetText(FPDF_PAGEOBJECT text_object,FPDF_TEXTPAGE text_page,void * buffer,unsigned long length)557 FPDFTextObj_GetText(FPDF_PAGEOBJECT text_object,
558 FPDF_TEXTPAGE text_page,
559 void* buffer,
560 unsigned long length) {
561 CPDF_TextObject* pTextObj = CPDFTextObjectFromFPDFPageObject(text_object);
562 if (!pTextObj)
563 return 0;
564
565 CPDF_TextPage* pTextPage = CPDFTextPageFromFPDFTextPage(text_page);
566 if (!pTextPage)
567 return 0;
568
569 WideString text = pTextPage->GetTextByObject(pTextObj);
570 return Utf16EncodeMaybeCopyAndReturnLength(text, buffer, length);
571 }
572
FPDFFont_Close(FPDF_FONT font)573 FPDF_EXPORT void FPDF_CALLCONV FPDFFont_Close(FPDF_FONT font) {
574 // Take back ownership from caller and release.
575 RetainPtr<CPDF_Font>().Unleak(CPDFFontFromFPDFFont(font));
576 }
577
578 FPDF_EXPORT FPDF_PAGEOBJECT FPDF_CALLCONV
FPDFPageObj_CreateTextObj(FPDF_DOCUMENT document,FPDF_FONT font,float font_size)579 FPDFPageObj_CreateTextObj(FPDF_DOCUMENT document,
580 FPDF_FONT font,
581 float font_size) {
582 CPDF_Document* pDoc = CPDFDocumentFromFPDFDocument(document);
583 CPDF_Font* pFont = CPDFFontFromFPDFFont(font);
584 if (!pDoc || !pFont)
585 return nullptr;
586
587 auto pTextObj = pdfium::MakeUnique<CPDF_TextObject>();
588 pTextObj->m_TextState.SetFont(
589 CPDF_DocPageData::FromDocument(pDoc)->GetFont(pFont->GetFontDict()));
590 pTextObj->m_TextState.SetFontSize(font_size);
591 pTextObj->DefaultStates();
592 return FPDFPageObjectFromCPDFPageObject(pTextObj.release());
593 }
594
595 FPDF_EXPORT FPDF_TEXT_RENDERMODE FPDF_CALLCONV
FPDFTextObj_GetTextRenderMode(FPDF_PAGEOBJECT text)596 FPDFTextObj_GetTextRenderMode(FPDF_PAGEOBJECT text) {
597 CPDF_TextObject* pTextObj = CPDFTextObjectFromFPDFPageObject(text);
598 if (!pTextObj)
599 return FPDF_TEXTRENDERMODE_UNKNOWN;
600 return static_cast<FPDF_TEXT_RENDERMODE>(pTextObj->m_TextState.GetTextMode());
601 }
602
603 FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV
FPDFTextObj_SetTextRenderMode(FPDF_PAGEOBJECT text,FPDF_TEXT_RENDERMODE render_mode)604 FPDFTextObj_SetTextRenderMode(FPDF_PAGEOBJECT text,
605 FPDF_TEXT_RENDERMODE render_mode) {
606 if (render_mode <= FPDF_TEXTRENDERMODE_UNKNOWN ||
607 render_mode > FPDF_TEXTRENDERMODE_LAST) {
608 return false;
609 }
610
611 CPDF_TextObject* pTextObj = CPDFTextObjectFromFPDFPageObject(text);
612 if (!pTextObj)
613 return false;
614
615 pTextObj->m_TextState.SetTextMode(
616 static_cast<TextRenderingMode>(render_mode));
617 return true;
618 }
619