1 // Copyright 2014 The PDFium Authors
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
6
7 #include "core/fpdftext/cpdf_textpage.h"
8
9 #include <math.h>
10 #include <stdint.h>
11
12 #include <algorithm>
13 #include <utility>
14 #include <vector>
15
16 #include "core/fpdfapi/font/cpdf_cidfont.h"
17 #include "core/fpdfapi/font/cpdf_font.h"
18 #include "core/fpdfapi/page/cpdf_form.h"
19 #include "core/fpdfapi/page/cpdf_formobject.h"
20 #include "core/fpdfapi/page/cpdf_page.h"
21 #include "core/fpdfapi/page/cpdf_pageobject.h"
22 #include "core/fpdfapi/page/cpdf_textobject.h"
23 #include "core/fpdfapi/parser/cpdf_dictionary.h"
24 #include "core/fpdfapi/parser/cpdf_string.h"
25 #include "core/fpdftext/unicodenormalizationdata.h"
26 #include "core/fxcrt/check.h"
27 #include "core/fxcrt/check_op.h"
28 #include "core/fxcrt/compiler_specific.h"
29 #include "core/fxcrt/data_vector.h"
30 #include "core/fxcrt/fx_bidi.h"
31 #include "core/fxcrt/fx_extension.h"
32 #include "core/fxcrt/fx_unicode.h"
33 #include "core/fxcrt/notreached.h"
34 #include "core/fxcrt/span.h"
35 #include "core/fxcrt/stl_util.h"
36
37 namespace {
38
39 constexpr float kDefaultFontSize = 1.0f;
40 constexpr float kSizeEpsilon = 0.01f;
41 constexpr std::array<pdfium::span<const uint16_t>, 3>
42 kUnicodeDataNormalizationMaps = {{kUnicodeDataNormalizationMap2,
43 kUnicodeDataNormalizationMap3,
44 kUnicodeDataNormalizationMap4}};
45
NormalizeThreshold(float threshold,int t1,int t2,int t3)46 float NormalizeThreshold(float threshold, int t1, int t2, int t3) {
47 DCHECK(t1 < t2);
48 DCHECK(t2 < t3);
49 if (threshold < t1)
50 return threshold / 2.0f;
51 if (threshold < t2)
52 return threshold / 4.0f;
53 if (threshold < t3)
54 return threshold / 5.0f;
55 return threshold / 6.0f;
56 }
57
CalculateBaseSpace(const CPDF_TextObject * pTextObj,const CFX_Matrix & matrix)58 float CalculateBaseSpace(const CPDF_TextObject* pTextObj,
59 const CFX_Matrix& matrix) {
60 const size_t nItems = pTextObj->CountItems();
61 const float char_space = pTextObj->text_state().GetCharSpace();
62 if (char_space == 0.0f || nItems < 3) {
63 return 0.0f;
64 }
65
66 bool bAllChar = true;
67 const float spacing = matrix.TransformDistance(char_space);
68 const float fontsize_h = pTextObj->text_state().GetFontSizeH();
69 float base_space = spacing;
70 for (size_t i = 0; i < nItems; ++i) {
71 CPDF_TextObject::Item item = pTextObj->GetItemInfo(i);
72 if (item.m_CharCode == 0xffffffff) {
73 float kerning = -fontsize_h * item.m_Origin.x / 1000;
74 base_space = std::min(base_space, kerning + spacing);
75 bAllChar = false;
76 }
77 }
78 if (base_space < 0.0 || (nItems == 3 && !bAllChar)) {
79 return 0.0f;
80 }
81
82 return base_space;
83 }
84
CalculateBaseSpaceAdjustment(const CPDF_TextObject * pTextObj,const CFX_Matrix & matrix)85 float CalculateBaseSpaceAdjustment(const CPDF_TextObject* pTextObj,
86 const CFX_Matrix& matrix) {
87 float char_space = pTextObj->text_state().GetCharSpace();
88 if (char_space > 0.001f) {
89 return -matrix.TransformDistance(char_space);
90 }
91 if (char_space < -0.001f) {
92 return matrix.TransformDistance(fabs(char_space));
93 }
94 return 0.0f;
95 }
96
GetUnicodeNormalization(wchar_t wch)97 DataVector<wchar_t> GetUnicodeNormalization(wchar_t wch) {
98 wch = wch & 0xFFFF;
99 wchar_t wFind = kUnicodeDataNormalization[wch];
100 if (!wFind) {
101 return DataVector<wchar_t>(1, wch);
102 }
103 if (wFind >= 0x8000) {
104 return DataVector<wchar_t>(1,
105 kUnicodeDataNormalizationMap1[wFind - 0x8000]);
106 }
107 wch = wFind & 0x0FFF;
108 wFind >>= 12;
109 auto pMap = kUnicodeDataNormalizationMaps[wFind - 2].subspan(wch);
110 if (wFind == 4) {
111 wFind = pMap.front();
112 pMap = pMap.subspan(1);
113 }
114 const auto range = pMap.first(wFind);
115 return DataVector<wchar_t>(range.begin(), range.end());
116 }
117
MaskPercentFilled(const std::vector<bool> & mask,int32_t start,int32_t end)118 float MaskPercentFilled(const std::vector<bool>& mask,
119 int32_t start,
120 int32_t end) {
121 if (start >= end)
122 return 0;
123 float count = std::count_if(mask.begin() + start, mask.begin() + end,
124 [](bool r) { return r; });
125 return count / (end - start);
126 }
127
IsControlChar(const CPDF_TextPage::CharInfo & char_info)128 bool IsControlChar(const CPDF_TextPage::CharInfo& char_info) {
129 switch (char_info.unicode()) {
130 case 0x2:
131 case 0x3:
132 case 0x93:
133 case 0x94:
134 case 0x96:
135 case 0x97:
136 case 0x98:
137 case 0xfffe:
138 return char_info.char_type() != CPDF_TextPage::CharType::kHyphen;
139 default:
140 return false;
141 }
142 }
143
IsHyphenCode(wchar_t c)144 bool IsHyphenCode(wchar_t c) {
145 return c == 0x2D || c == 0xAD;
146 }
147
IsRectIntersect(const CFX_FloatRect & rect1,const CFX_FloatRect & rect2)148 bool IsRectIntersect(const CFX_FloatRect& rect1, const CFX_FloatRect& rect2) {
149 CFX_FloatRect rect = rect1;
150 rect.Intersect(rect2);
151 return !rect.IsEmpty();
152 }
153
IsRightToLeft(const CPDF_TextObject & text_obj)154 bool IsRightToLeft(const CPDF_TextObject& text_obj) {
155 RetainPtr<const CPDF_Font> font = text_obj.GetFont();
156 const size_t nItems = text_obj.CountItems();
157 WideString str;
158 str.Reserve(nItems);
159 for (size_t i = 0; i < nItems; ++i) {
160 CPDF_TextObject::Item item = text_obj.GetItemInfo(i);
161 if (item.m_CharCode == 0xffffffff)
162 continue;
163 WideString unicode = font->UnicodeFromCharCode(item.m_CharCode);
164 wchar_t wChar = !unicode.IsEmpty() ? unicode[0] : 0;
165 if (wChar == 0)
166 wChar = item.m_CharCode;
167 if (wChar)
168 str += wChar;
169 }
170 return CFX_BidiString(str).OverallDirection() ==
171 CFX_BidiChar::Direction::kRight;
172 }
173
GetCharWidth(uint32_t charCode,CPDF_Font * pFont)174 int GetCharWidth(uint32_t charCode, CPDF_Font* pFont) {
175 if (charCode == CPDF_Font::kInvalidCharCode)
176 return 0;
177
178 int w = pFont->GetCharWidthF(charCode);
179 if (w > 0)
180 return w;
181
182 ByteString str;
183 pFont->AppendChar(&str, charCode);
184 w = pFont->GetStringWidth(str.AsStringView());
185 if (w > 0)
186 return w;
187
188 FX_RECT rect = pFont->GetCharBBox(charCode);
189 if (!rect.Valid())
190 return 0;
191
192 return std::max(rect.Width(), 0);
193 }
194
CalculateSpaceThreshold(CPDF_Font * font,float fontsize_h,uint32_t char_code)195 float CalculateSpaceThreshold(CPDF_Font* font,
196 float fontsize_h,
197 uint32_t char_code) {
198 const uint32_t space_charcode = font->CharCodeFromUnicode(' ');
199 float threshold = 0;
200 if (space_charcode != CPDF_Font::kInvalidCharCode) {
201 threshold = fontsize_h * font->GetCharWidthF(space_charcode) / 1000;
202 }
203 if (threshold > fontsize_h / 3) {
204 threshold = 0;
205 } else {
206 threshold /= 2;
207 }
208 if (threshold == 0) {
209 threshold = GetCharWidth(char_code, font);
210 threshold = NormalizeThreshold(threshold, 300, 500, 700);
211 threshold = fontsize_h * threshold / 1000;
212 }
213 return threshold;
214 }
215
GenerateSpace(const CFX_PointF & pos,float last_pos,float this_width,float last_width,float threshold)216 bool GenerateSpace(const CFX_PointF& pos,
217 float last_pos,
218 float this_width,
219 float last_width,
220 float threshold) {
221 if (fabs(last_pos + last_width - pos.x) <= threshold)
222 return false;
223
224 float threshold_pos = threshold + last_width;
225 float pos_difference = pos.x - last_pos;
226 if (fabs(pos_difference) > threshold_pos)
227 return true;
228 if (pos.x < 0 && -threshold_pos > pos_difference)
229 return true;
230 return pos_difference > this_width + last_width;
231 }
232
EndHorizontalLine(const CFX_FloatRect & this_rect,const CFX_FloatRect & prev_rect)233 bool EndHorizontalLine(const CFX_FloatRect& this_rect,
234 const CFX_FloatRect& prev_rect) {
235 if (this_rect.Height() <= 4.5 || prev_rect.Height() <= 4.5)
236 return false;
237
238 float top = std::min(this_rect.top, prev_rect.top);
239 float bottom = std::max(this_rect.bottom, prev_rect.bottom);
240 return bottom >= top;
241 }
242
EndVerticalLine(const CFX_FloatRect & this_rect,const CFX_FloatRect & prev_rect,const CFX_FloatRect & curline_rect,float this_fontsize,float prev_fontsize)243 bool EndVerticalLine(const CFX_FloatRect& this_rect,
244 const CFX_FloatRect& prev_rect,
245 const CFX_FloatRect& curline_rect,
246 float this_fontsize,
247 float prev_fontsize) {
248 if (this_rect.Width() <= this_fontsize * 0.1f ||
249 prev_rect.Width() <= prev_fontsize * 0.1f) {
250 return false;
251 }
252
253 float left = std::max(this_rect.left, curline_rect.left);
254 float right = std::min(this_rect.right, curline_rect.right);
255 return right <= left;
256 }
257
GetPageMatrix(const CPDF_Page * pPage)258 CFX_Matrix GetPageMatrix(const CPDF_Page* pPage) {
259 const FX_RECT rect(0, 0, static_cast<int>(pPage->GetPageWidth()),
260 static_cast<int>(pPage->GetPageHeight()));
261 return pPage->GetDisplayMatrix(rect, 0);
262 }
263
GetFontSize(const CPDF_TextObject * text_object)264 float GetFontSize(const CPDF_TextObject* text_object) {
265 bool has_font = text_object && text_object->GetFont();
266 return has_font ? text_object->GetFontSize() : kDefaultFontSize;
267 }
268
GetLooseBounds(const CPDF_TextPage::CharInfo & charinfo)269 CFX_FloatRect GetLooseBounds(const CPDF_TextPage::CharInfo& charinfo) {
270 float font_size = GetFontSize(charinfo.text_object());
271 if (charinfo.text_object() && !FXSYS_IsFloatZero(font_size)) {
272 bool is_vert_writing = charinfo.text_object()->GetFont()->IsVertWriting();
273 if (is_vert_writing && charinfo.text_object()->GetFont()->IsCIDFont()) {
274 CPDF_CIDFont* pCIDFont = charinfo.text_object()->GetFont()->AsCIDFont();
275 uint16_t cid = pCIDFont->CIDFromCharCode(charinfo.char_code());
276
277 CFX_Point16 vertical_origin = pCIDFont->GetVertOrigin(cid);
278 double offsetx = (vertical_origin.x - 500) * font_size / 1000.0;
279 double offsety = vertical_origin.y * font_size / 1000.0;
280 int16_t vert_width = pCIDFont->GetVertWidth(cid);
281 double height = vert_width * font_size / 1000.0;
282
283 float left = charinfo.origin().x + offsetx;
284 float right = left + font_size;
285 float bottom = charinfo.origin().y + offsety;
286 float top = bottom + height;
287 return CFX_FloatRect(left, bottom, right, top);
288 }
289
290 int ascent = charinfo.text_object()->GetFont()->GetTypeAscent();
291 int descent = charinfo.text_object()->GetFont()->GetTypeDescent();
292 if (ascent != descent) {
293 float width = charinfo.matrix().a *
294 charinfo.text_object()->GetCharWidth(charinfo.char_code());
295 float font_scale = charinfo.matrix().a * font_size / (ascent - descent);
296
297 float left = charinfo.origin().x;
298 float right = charinfo.origin().x + (is_vert_writing ? -width : width);
299 float bottom = charinfo.origin().y + descent * font_scale;
300 float top = charinfo.origin().y + ascent * font_scale;
301 return CFX_FloatRect(left, bottom, right, top);
302 }
303 }
304
305 // Fallback to the tight bounds in empty text scenarios, or bad font metrics
306 return charinfo.char_box();
307 }
308
309 } // namespace
310
311 CPDF_TextPage::TransformedTextObject::TransformedTextObject() = default;
312
313 CPDF_TextPage::TransformedTextObject::TransformedTextObject(
314 const TransformedTextObject& that) = default;
315
316 CPDF_TextPage::TransformedTextObject::~TransformedTextObject() = default;
317
318 CPDF_TextPage::CharInfo::CharInfo() = default;
319
CharInfo(CharType char_type,uint32_t char_code,wchar_t unicode,CFX_PointF origin,CFX_FloatRect char_box,CFX_Matrix matrix,CPDF_TextObject * text_object)320 CPDF_TextPage::CharInfo::CharInfo(CharType char_type,
321 uint32_t char_code,
322 wchar_t unicode,
323 CFX_PointF origin,
324 CFX_FloatRect char_box,
325 CFX_Matrix matrix,
326 CPDF_TextObject* text_object)
327 : char_type_(char_type),
328 unicode_(unicode),
329 char_code_(char_code),
330 origin_(origin),
331 char_box_(char_box),
332 matrix_(matrix),
333 text_object_(text_object) {}
334
335 CPDF_TextPage::CharInfo::CharInfo(const CharInfo&) = default;
336
337 CPDF_TextPage::CharInfo::~CharInfo() = default;
338
CPDF_TextPage(const CPDF_Page * pPage,bool rtl)339 CPDF_TextPage::CPDF_TextPage(const CPDF_Page* pPage, bool rtl)
340 : m_pPage(pPage), m_rtl(rtl), m_DisplayMatrix(GetPageMatrix(pPage)) {
341 Init();
342 }
343
344 CPDF_TextPage::~CPDF_TextPage() = default;
345
Init()346 void CPDF_TextPage::Init() {
347 m_TextBuf.SetAllocStep(10240);
348 ProcessObject();
349
350 const int nCount = CountChars();
351 if (nCount)
352 m_CharIndices.push_back({0, 0});
353
354 bool skipped = false;
355 for (int i = 0; i < nCount; ++i) {
356 const CharInfo& charinfo = m_CharList[i];
357 if (charinfo.char_type() == CharType::kGenerated ||
358 (charinfo.unicode() != 0 && !IsControlChar(charinfo)) ||
359 (charinfo.unicode() == 0 && charinfo.char_code() != 0)) {
360 m_CharIndices.back().count++;
361 skipped = true;
362 } else {
363 if (skipped) {
364 m_CharIndices.push_back({i + 1, 0});
365 skipped = false;
366 } else {
367 m_CharIndices.back().index = i + 1;
368 }
369 }
370 }
371 }
372
CountChars() const373 int CPDF_TextPage::CountChars() const {
374 return fxcrt::CollectionSize<int>(m_CharList);
375 }
376
CharIndexFromTextIndex(int text_index) const377 int CPDF_TextPage::CharIndexFromTextIndex(int text_index) const {
378 int count = 0;
379 for (const auto& info : m_CharIndices) {
380 count += info.count;
381 if (count > text_index)
382 return text_index - count + info.count + info.index;
383 }
384 return -1;
385 }
386
TextIndexFromCharIndex(int char_index) const387 int CPDF_TextPage::TextIndexFromCharIndex(int char_index) const {
388 int count = 0;
389 for (const auto& info : m_CharIndices) {
390 int text_index = char_index - info.index;
391 if (text_index < info.count)
392 return text_index >= 0 ? text_index + count : -1;
393
394 count += info.count;
395 }
396 return -1;
397 }
398
GetRectArray(int start,int count) const399 std::vector<CFX_FloatRect> CPDF_TextPage::GetRectArray(int start,
400 int count) const {
401 std::vector<CFX_FloatRect> rects;
402 if (start < 0 || count == 0)
403 return rects;
404
405 const int number_of_chars = CountChars();
406 if (start >= number_of_chars)
407 return rects;
408
409 if (count < 0 || start + count > number_of_chars)
410 count = number_of_chars - start;
411 DCHECK(count > 0);
412
413 const CPDF_TextObject* text_object = nullptr;
414 CFX_FloatRect rect;
415 int pos = start;
416 bool is_new_rect = true;
417 while (count--) {
418 const CharInfo& charinfo = m_CharList[pos++];
419 if (charinfo.char_type() == CharType::kGenerated) {
420 continue;
421 }
422 if (charinfo.char_box().Width() < kSizeEpsilon ||
423 charinfo.char_box().Height() < kSizeEpsilon) {
424 continue;
425 }
426 if (!text_object)
427 text_object = charinfo.text_object();
428 if (text_object != charinfo.text_object()) {
429 rects.push_back(rect);
430 text_object = charinfo.text_object();
431 is_new_rect = true;
432 }
433 if (is_new_rect) {
434 is_new_rect = false;
435 rect = charinfo.char_box();
436 rect.Normalize();
437 continue;
438 }
439 rect.Union(charinfo.char_box());
440 }
441 rects.push_back(rect);
442 return rects;
443 }
444
GetIndexAtPos(const CFX_PointF & point,const CFX_SizeF & tolerance) const445 int CPDF_TextPage::GetIndexAtPos(const CFX_PointF& point,
446 const CFX_SizeF& tolerance) const {
447 int pos;
448 int NearPos = -1;
449 double xdif = 5000;
450 double ydif = 5000;
451 const int nCount = CountChars();
452 for (pos = 0; pos < nCount; ++pos) {
453 const CFX_FloatRect& orig_charrect = m_CharList[pos].char_box();
454 if (orig_charrect.Contains(point))
455 break;
456
457 if (tolerance.width <= 0 && tolerance.height <= 0)
458 continue;
459
460 CFX_FloatRect charrect = orig_charrect;
461 charrect.Normalize();
462 CFX_FloatRect char_rect_ext(charrect.left - tolerance.width / 2,
463 charrect.bottom - tolerance.height / 2,
464 charrect.right + tolerance.width / 2,
465 charrect.top + tolerance.height / 2);
466 if (!char_rect_ext.Contains(point))
467 continue;
468
469 double curXdif =
470 std::min(fabs(point.x - charrect.left), fabs(point.x - charrect.right));
471 double curYdif =
472 std::min(fabs(point.y - charrect.bottom), fabs(point.y - charrect.top));
473 if (curYdif + curXdif < xdif + ydif) {
474 ydif = curYdif;
475 xdif = curXdif;
476 NearPos = pos;
477 }
478 }
479 return pos < nCount ? pos : NearPos;
480 }
481
GetTextByPredicate(const std::function<bool (const CharInfo &)> & predicate) const482 WideString CPDF_TextPage::GetTextByPredicate(
483 const std::function<bool(const CharInfo&)>& predicate) const {
484 float posy = 0;
485 bool IsContainPreChar = false;
486 bool IsAddLineFeed = false;
487 WideString strText;
488 for (const auto& charinfo : m_CharList) {
489 if (predicate(charinfo)) {
490 if (fabs(posy - charinfo.origin().y) > 0 && !IsContainPreChar &&
491 IsAddLineFeed) {
492 posy = charinfo.origin().y;
493 if (!strText.IsEmpty())
494 strText += L"\r\n";
495 }
496 IsContainPreChar = true;
497 IsAddLineFeed = false;
498 if (charinfo.unicode()) {
499 strText += charinfo.unicode();
500 }
501 } else if (charinfo.unicode() == L' ') {
502 if (IsContainPreChar) {
503 strText += L' ';
504 IsContainPreChar = false;
505 IsAddLineFeed = false;
506 }
507 } else {
508 IsContainPreChar = false;
509 IsAddLineFeed = true;
510 }
511 }
512 return strText;
513 }
514
GetTextByRect(const CFX_FloatRect & rect) const515 WideString CPDF_TextPage::GetTextByRect(const CFX_FloatRect& rect) const {
516 return GetTextByPredicate([&rect](const CharInfo& charinfo) {
517 return IsRectIntersect(rect, charinfo.char_box());
518 });
519 }
520
GetTextByObject(const CPDF_TextObject * pTextObj) const521 WideString CPDF_TextPage::GetTextByObject(
522 const CPDF_TextObject* pTextObj) const {
523 return GetTextByPredicate([pTextObj](const CharInfo& charinfo) {
524 return charinfo.text_object() == pTextObj;
525 });
526 }
527
GetCharInfo(size_t index) const528 const CPDF_TextPage::CharInfo& CPDF_TextPage::GetCharInfo(size_t index) const {
529 CHECK_LT(index, m_CharList.size());
530 return m_CharList[index];
531 }
532
GetCharInfo(size_t index)533 CPDF_TextPage::CharInfo& CPDF_TextPage::GetCharInfo(size_t index) {
534 CHECK_LT(index, m_CharList.size());
535 return m_CharList[index];
536 }
537
GetCharFontSize(size_t index) const538 float CPDF_TextPage::GetCharFontSize(size_t index) const {
539 CHECK_LT(index, m_CharList.size());
540 return GetFontSize(m_CharList[index].text_object());
541 }
542
GetCharLooseBounds(size_t index) const543 CFX_FloatRect CPDF_TextPage::GetCharLooseBounds(size_t index) const {
544 return GetLooseBounds(GetCharInfo(index));
545 }
546
GetPageText(int start,int count) const547 WideString CPDF_TextPage::GetPageText(int start, int count) const {
548 if (start < 0 || start >= CountChars() || count <= 0 || m_CharList.empty() ||
549 m_TextBuf.IsEmpty()) {
550 return WideString();
551 }
552
553 const int count_chars = CountChars();
554 int text_start = TextIndexFromCharIndex(start);
555
556 // If the character at |start| is a non-printing character, then
557 // TextIndexFromCharIndex will return -1, so scan ahead to the first printing
558 // character.
559 while (text_start < 0) {
560 if (start >= count_chars)
561 return WideString();
562 start++;
563 text_start = TextIndexFromCharIndex(start);
564 }
565
566 count = std::min(count, count_chars - start);
567
568 int last = start + count - 1;
569 int text_last = TextIndexFromCharIndex(last);
570
571 // If the character at |last| is a non-printing character, then
572 // TextIndexFromCharIndex will return -1, so scan back to the last printing
573 // character.
574 while (text_last < 0) {
575 if (last < text_start)
576 return WideString();
577
578 last--;
579 text_last = TextIndexFromCharIndex(last);
580 }
581
582 if (text_last < text_start)
583 return WideString();
584
585 int text_count = text_last - text_start + 1;
586
587 return WideString(m_TextBuf.AsStringView().Substr(text_start, text_count));
588 }
589
CountRects(int start,int nCount)590 int CPDF_TextPage::CountRects(int start, int nCount) {
591 if (start < 0)
592 return -1;
593
594 m_SelRects = GetRectArray(start, nCount);
595 return fxcrt::CollectionSize<int>(m_SelRects);
596 }
597
GetRect(int rectIndex,CFX_FloatRect * pRect) const598 bool CPDF_TextPage::GetRect(int rectIndex, CFX_FloatRect* pRect) const {
599 if (!fxcrt::IndexInBounds(m_SelRects, rectIndex))
600 return false;
601
602 *pRect = m_SelRects[rectIndex];
603 return true;
604 }
605
FindTextlineFlowOrientation() const606 CPDF_TextPage::TextOrientation CPDF_TextPage::FindTextlineFlowOrientation()
607 const {
608 const int32_t nPageWidth = static_cast<int32_t>(m_pPage->GetPageWidth());
609 const int32_t nPageHeight = static_cast<int32_t>(m_pPage->GetPageHeight());
610 if (nPageWidth <= 0 || nPageHeight <= 0)
611 return TextOrientation::kUnknown;
612
613 std::vector<bool> nHorizontalMask(nPageWidth);
614 std::vector<bool> nVerticalMask(nPageHeight);
615 float fLineHeight = 0.0f;
616 int32_t nStartH = nPageWidth;
617 int32_t nEndH = 0;
618 int32_t nStartV = nPageHeight;
619 int32_t nEndV = 0;
620 for (const auto& pPageObj : *m_pPage) {
621 if (!pPageObj->IsActive() || !pPageObj->IsText()) {
622 continue;
623 }
624
625 int32_t minH = static_cast<int32_t>(
626 std::clamp<float>(pPageObj->GetRect().left, 0.0f, nPageWidth));
627 int32_t maxH = static_cast<int32_t>(
628 std::clamp<float>(pPageObj->GetRect().right, 0.0f, nPageWidth));
629 int32_t minV = static_cast<int32_t>(
630 std::clamp<float>(pPageObj->GetRect().bottom, 0.0f, nPageHeight));
631 int32_t maxV = static_cast<int32_t>(
632 std::clamp<float>(pPageObj->GetRect().top, 0.0f, nPageHeight));
633 if (minH >= maxH || minV >= maxV)
634 continue;
635
636 for (int32_t i = minH; i < maxH; ++i)
637 nHorizontalMask[i] = true;
638 for (int32_t i = minV; i < maxV; ++i)
639 nVerticalMask[i] = true;
640
641 nStartH = std::min(nStartH, minH);
642 nEndH = std::max(nEndH, maxH);
643 nStartV = std::min(nStartV, minV);
644 nEndV = std::max(nEndV, maxV);
645
646 if (fLineHeight <= 0.0f)
647 fLineHeight = pPageObj->GetRect().Height();
648 }
649 const int32_t nDoubleLineHeight = 2 * fLineHeight;
650 if ((nEndV - nStartV) < nDoubleLineHeight)
651 return TextOrientation::kHorizontal;
652 if ((nEndH - nStartH) < nDoubleLineHeight)
653 return TextOrientation::kVertical;
654
655 const float nSumH = MaskPercentFilled(nHorizontalMask, nStartH, nEndH);
656 if (nSumH > 0.8f)
657 return TextOrientation::kHorizontal;
658
659 const float nSumV = MaskPercentFilled(nVerticalMask, nStartV, nEndV);
660 if (nSumH > nSumV)
661 return TextOrientation::kHorizontal;
662 if (nSumH < nSumV)
663 return TextOrientation::kVertical;
664 return TextOrientation::kUnknown;
665 }
666
AppendGeneratedCharacter(wchar_t unicode,const CFX_Matrix & form_matrix,bool use_temp_buffer)667 void CPDF_TextPage::AppendGeneratedCharacter(wchar_t unicode,
668 const CFX_Matrix& form_matrix,
669 bool use_temp_buffer) {
670 std::optional<CharInfo> charinfo = GenerateCharInfo(unicode, form_matrix);
671 if (!charinfo.has_value()) {
672 return;
673 }
674
675 if (use_temp_buffer) {
676 m_TempTextBuf.AppendChar(unicode);
677 m_TempCharList.push_back(charinfo.value());
678 } else {
679 m_TextBuf.AppendChar(unicode);
680 m_CharList.push_back(charinfo.value());
681 }
682 }
683
ProcessObject()684 void CPDF_TextPage::ProcessObject() {
685 if (m_pPage->GetActivePageObjectCount() == 0) {
686 return;
687 }
688
689 m_TextlineDir = FindTextlineFlowOrientation();
690 for (auto it = m_pPage->begin(); it != m_pPage->end(); ++it) {
691 CPDF_PageObject* pObj = it->get();
692 if (!pObj->IsActive()) {
693 continue;
694 }
695
696 if (pObj->IsText()) {
697 ProcessTextObject(pObj->AsText(), CFX_Matrix(), m_pPage, it);
698 } else if (pObj->IsForm()) {
699 ProcessFormObject(pObj->AsForm(), CFX_Matrix());
700 }
701 }
702 for (const auto& obj : mTextObjects)
703 ProcessTextObject(obj);
704
705 mTextObjects.clear();
706 CloseTempLine();
707 }
708
ProcessFormObject(CPDF_FormObject * pFormObj,const CFX_Matrix & form_matrix)709 void CPDF_TextPage::ProcessFormObject(CPDF_FormObject* pFormObj,
710 const CFX_Matrix& form_matrix) {
711 CFX_Matrix curFormMatrix = pFormObj->form_matrix() * form_matrix;
712 const CPDF_PageObjectHolder* pHolder = pFormObj->form();
713 for (auto it = pHolder->begin(); it != pHolder->end(); ++it) {
714 CPDF_PageObject* pPageObj = it->get();
715 if (!pPageObj->IsActive()) {
716 continue;
717 }
718
719 if (pPageObj->IsText()) {
720 ProcessTextObject(pPageObj->AsText(), curFormMatrix, pHolder, it);
721 } else if (pPageObj->IsForm()) {
722 ProcessFormObject(pPageObj->AsForm(), curFormMatrix);
723 }
724 }
725 }
726
AddCharInfoByLRDirection(wchar_t wChar,const CharInfo & info)727 void CPDF_TextPage::AddCharInfoByLRDirection(wchar_t wChar,
728 const CharInfo& info) {
729 CharInfo info2 = info;
730 if (IsControlChar(info2)) {
731 m_CharList.push_back(info2);
732 return;
733 }
734 DataVector<wchar_t> normalized;
735 if (wChar >= 0xFB00 && wChar <= 0xFB06)
736 normalized = GetUnicodeNormalization(wChar);
737 if (normalized.empty()) {
738 m_TextBuf.AppendChar(wChar);
739 m_CharList.push_back(info2);
740 return;
741 }
742 info2.set_char_type(CharType::kPiece);
743 for (wchar_t normalized_char : normalized) {
744 info2.set_unicode(normalized_char);
745 m_TextBuf.AppendChar(normalized_char);
746 m_CharList.push_back(info2);
747 }
748 }
749
AddCharInfoByRLDirection(wchar_t wChar,const CharInfo & info)750 void CPDF_TextPage::AddCharInfoByRLDirection(wchar_t wChar,
751 const CharInfo& info) {
752 CharInfo info2 = info;
753 if (IsControlChar(info2)) {
754 m_CharList.push_back(info2);
755 return;
756 }
757 wChar = pdfium::unicode::GetMirrorChar(wChar);
758 DataVector<wchar_t> normalized = GetUnicodeNormalization(wChar);
759 if (normalized.empty()) {
760 info2.set_unicode(wChar);
761 m_TextBuf.AppendChar(wChar);
762 m_CharList.push_back(info2);
763 return;
764 }
765 info2.set_char_type(CharType::kPiece);
766 for (wchar_t normalized_char : normalized) {
767 info2.set_unicode(normalized_char);
768 m_TextBuf.AppendChar(normalized_char);
769 m_CharList.push_back(info2);
770 }
771 }
772
CloseTempLine()773 void CPDF_TextPage::CloseTempLine() {
774 if (m_TempCharList.empty())
775 return;
776
777 WideString str = m_TempTextBuf.MakeString();
778 bool bPrevSpace = false;
779 for (size_t i = 0; i < str.GetLength(); ++i) {
780 if (str[i] != ' ') {
781 bPrevSpace = false;
782 continue;
783 }
784 if (bPrevSpace) {
785 m_TempTextBuf.Delete(i, 1);
786 m_TempCharList.erase(m_TempCharList.begin() + i);
787 str.Delete(i);
788 --i;
789 }
790 bPrevSpace = true;
791 }
792 CFX_BidiString bidi(str);
793 if (m_rtl)
794 bidi.SetOverallDirectionRight();
795 CFX_BidiChar::Direction eCurrentDirection = bidi.OverallDirection();
796 for (const auto& segment : bidi) {
797 if (segment.direction == CFX_BidiChar::Direction::kRight ||
798 (segment.direction == CFX_BidiChar::Direction::kNeutral &&
799 eCurrentDirection == CFX_BidiChar::Direction::kRight)) {
800 eCurrentDirection = CFX_BidiChar::Direction::kRight;
801 for (int m = segment.start + segment.count; m > segment.start; --m)
802 AddCharInfoByRLDirection(str[m - 1], m_TempCharList[m - 1]);
803 } else {
804 if (segment.direction != CFX_BidiChar::Direction::kLeftWeak) {
805 eCurrentDirection = CFX_BidiChar::Direction::kLeft;
806 }
807 for (int m = segment.start; m < segment.start + segment.count; ++m)
808 AddCharInfoByLRDirection(str[m], m_TempCharList[m]);
809 }
810 }
811 m_TempCharList.clear();
812 m_TempTextBuf.Delete(0, m_TempTextBuf.GetLength());
813 }
814
ProcessTextObject(CPDF_TextObject * pTextObj,const CFX_Matrix & form_matrix,const CPDF_PageObjectHolder * pObjList,CPDF_PageObjectHolder::const_iterator ObjPos)815 void CPDF_TextPage::ProcessTextObject(
816 CPDF_TextObject* pTextObj,
817 const CFX_Matrix& form_matrix,
818 const CPDF_PageObjectHolder* pObjList,
819 CPDF_PageObjectHolder::const_iterator ObjPos) {
820 if (fabs(pTextObj->GetRect().Width()) < kSizeEpsilon)
821 return;
822
823 size_t count = mTextObjects.size();
824 TransformedTextObject new_obj;
825 new_obj.m_pTextObj = pTextObj;
826 new_obj.m_formMatrix = form_matrix;
827 if (count == 0) {
828 mTextObjects.push_back(new_obj);
829 return;
830 }
831 if (IsSameAsPreTextObject(pTextObj, pObjList, ObjPos))
832 return;
833
834 TransformedTextObject prev_obj = mTextObjects[count - 1];
835 size_t nItem = prev_obj.m_pTextObj->CountItems();
836 if (nItem == 0)
837 return;
838
839 CPDF_TextObject::Item item = prev_obj.m_pTextObj->GetItemInfo(nItem - 1);
840 float prev_width =
841 GetCharWidth(item.m_CharCode, prev_obj.m_pTextObj->GetFont().Get()) *
842 prev_obj.m_pTextObj->GetFontSize() / 1000;
843
844 CFX_Matrix prev_matrix =
845 prev_obj.m_pTextObj->GetTextMatrix() * prev_obj.m_formMatrix;
846 prev_width = prev_matrix.TransformDistance(fabs(prev_width));
847 item = pTextObj->GetItemInfo(0);
848 float this_width = GetCharWidth(item.m_CharCode, pTextObj->GetFont().Get()) *
849 pTextObj->GetFontSize() / 1000;
850 this_width = fabs(this_width);
851
852 CFX_Matrix this_matrix = pTextObj->GetTextMatrix() * form_matrix;
853 this_width = this_matrix.TransformDistance(fabs(this_width));
854
855 float threshold = std::max(prev_width, this_width) / 4;
856 CFX_PointF prev_pos = m_DisplayMatrix.Transform(
857 prev_obj.m_formMatrix.Transform(prev_obj.m_pTextObj->GetPos()));
858 CFX_PointF this_pos =
859 m_DisplayMatrix.Transform(form_matrix.Transform(pTextObj->GetPos()));
860 if (fabs(this_pos.y - prev_pos.y) > threshold * 2) {
861 for (size_t i = 0; i < count; ++i)
862 ProcessTextObject(mTextObjects[i]);
863 mTextObjects.clear();
864 mTextObjects.push_back(new_obj);
865 return;
866 }
867
868 for (size_t i = count; i > 0; --i) {
869 TransformedTextObject prev_text_obj = mTextObjects[i - 1];
870 CFX_PointF new_prev_pos =
871 m_DisplayMatrix.Transform(prev_text_obj.m_formMatrix.Transform(
872 prev_text_obj.m_pTextObj->GetPos()));
873 if (this_pos.x >= new_prev_pos.x) {
874 mTextObjects.insert(mTextObjects.begin() + i, new_obj);
875 return;
876 }
877 }
878 mTextObjects.insert(mTextObjects.begin(), new_obj);
879 }
880
PreMarkedContent(const CPDF_TextObject * pTextObj)881 CPDF_TextPage::MarkedContentState CPDF_TextPage::PreMarkedContent(
882 const CPDF_TextObject* pTextObj) {
883 const CPDF_ContentMarks* pMarks = pTextObj->GetContentMarks();
884 const size_t nContentMarks = pMarks->CountItems();
885 if (nContentMarks == 0)
886 return MarkedContentState::kPass;
887
888 WideString actual_text;
889 bool bExist = false;
890 RetainPtr<const CPDF_Dictionary> pDict;
891 for (size_t i = 0; i < nContentMarks; ++i) {
892 const CPDF_ContentMarkItem* item = pMarks->GetItem(i);
893 pDict = item->GetParam();
894 if (!pDict)
895 continue;
896 RetainPtr<const CPDF_String> temp = pDict->GetStringFor("ActualText");
897 if (temp) {
898 bExist = true;
899 actual_text = temp->GetUnicodeText();
900 }
901 }
902 if (!bExist)
903 return MarkedContentState::kPass;
904
905 if (m_pPrevTextObj) {
906 const CPDF_ContentMarks* pPrevMarks = m_pPrevTextObj->GetContentMarks();
907 if (pPrevMarks->CountItems() == nContentMarks &&
908 pPrevMarks->GetItem(nContentMarks - 1)->GetParam() == pDict) {
909 return MarkedContentState::kDone;
910 }
911 }
912
913 if (actual_text.IsEmpty()) {
914 return MarkedContentState::kPass;
915 }
916
917 RetainPtr<CPDF_Font> pFont = pTextObj->GetFont();
918 bExist = false;
919 for (size_t i = 0; i < actual_text.GetLength(); ++i) {
920 if (pFont->CharCodeFromUnicode(actual_text[i]) !=
921 CPDF_Font::kInvalidCharCode) {
922 bExist = true;
923 break;
924 }
925 }
926 if (!bExist)
927 return MarkedContentState::kPass;
928
929 bExist = false;
930 for (size_t i = 0; i < actual_text.GetLength(); ++i) {
931 wchar_t wChar = actual_text[i];
932 if ((wChar > 0x80 && wChar < 0xFFFD) || (wChar <= 0x80 && isprint(wChar))) {
933 bExist = true;
934 break;
935 }
936 }
937 if (!bExist)
938 return MarkedContentState::kDone;
939
940 return MarkedContentState::kDelay;
941 }
942
ProcessMarkedContent(const TransformedTextObject & obj)943 void CPDF_TextPage::ProcessMarkedContent(const TransformedTextObject& obj) {
944 CPDF_TextObject* const pTextObj = obj.m_pTextObj;
945 const CPDF_ContentMarks* pMarks = pTextObj->GetContentMarks();
946 const size_t nContentMarks = pMarks->CountItems();
947 WideString actual_text;
948 for (size_t n = 0; n < nContentMarks; ++n) {
949 const CPDF_ContentMarkItem* item = pMarks->GetItem(n);
950 RetainPtr<const CPDF_Dictionary> pDict = item->GetParam();
951 if (pDict) {
952 actual_text = pDict->GetUnicodeTextFor("ActualText");
953 }
954 }
955 if (actual_text.IsEmpty()) {
956 return;
957 }
958
959 const bool bR2L = IsRightToLeft(*pTextObj);
960 CFX_Matrix matrix = pTextObj->GetTextMatrix() * obj.m_formMatrix;
961 CFX_FloatRect rect = pTextObj->GetRect();
962 float step = 0;
963
964 if (bR2L) {
965 rect.left = rect.right - (rect.Width() / actual_text.GetLength());
966 step = -rect.Width();
967 } else {
968 rect.right = rect.left + (rect.Width() / actual_text.GetLength());
969 step = rect.Width();
970 }
971
972 RetainPtr<CPDF_Font> const font = pTextObj->GetFont();
973 for (size_t k = 0; k < actual_text.GetLength(); ++k) {
974 wchar_t wChar = actual_text[k];
975 if (wChar <= 0x80 && !isprint(wChar)) {
976 wChar = 0x20;
977 }
978 if (wChar >= 0xFFFD) {
979 continue;
980 }
981
982 CFX_FloatRect char_box(rect);
983 char_box.Translate(k * step, 0);
984 m_TempCharList.push_back(
985 CharInfo(CharType::kPiece, font->CharCodeFromUnicode(wChar), wChar,
986 pTextObj->GetPos(), char_box, matrix, pTextObj));
987 }
988 }
989
FindPreviousTextObject()990 void CPDF_TextPage::FindPreviousTextObject() {
991 const CharInfo* pPrevCharInfo = GetPrevCharInfo();
992 if (!pPrevCharInfo)
993 return;
994
995 if (pPrevCharInfo->text_object()) {
996 m_pPrevTextObj = pPrevCharInfo->text_object();
997 }
998 }
999
SwapTempTextBuf(size_t iCharListStartAppend,size_t iBufStartAppend)1000 void CPDF_TextPage::SwapTempTextBuf(size_t iCharListStartAppend,
1001 size_t iBufStartAppend) {
1002 DCHECK(!m_TempCharList.empty());
1003 if (iCharListStartAppend < m_TempCharList.size()) {
1004 auto fwd = m_TempCharList.begin() + iCharListStartAppend;
1005 auto rev = m_TempCharList.end() - 1;
1006 for (; fwd < rev; ++fwd, --rev) {
1007 std::swap(*fwd, *rev);
1008 }
1009 }
1010 pdfium::span<wchar_t> temp_span = m_TempTextBuf.GetWideSpan();
1011 DCHECK(!temp_span.empty());
1012 if (iBufStartAppend < temp_span.size()) {
1013 pdfium::span<wchar_t> reverse_span = temp_span.subspan(iBufStartAppend);
1014 std::reverse(reverse_span.begin(), reverse_span.end());
1015 }
1016 }
1017
ProcessTextObject(const TransformedTextObject & obj)1018 void CPDF_TextPage::ProcessTextObject(const TransformedTextObject& obj) {
1019 CPDF_TextObject* const pTextObj = obj.m_pTextObj;
1020 if (fabs(pTextObj->GetRect().Width()) < kSizeEpsilon) {
1021 return;
1022 }
1023
1024 const CFX_Matrix form_matrix = obj.m_formMatrix;
1025 const MarkedContentState ePreMKC = PreMarkedContent(pTextObj);
1026 if (ePreMKC == MarkedContentState::kDone) {
1027 m_pPrevTextObj = pTextObj;
1028 m_PrevMatrix = form_matrix;
1029 return;
1030 }
1031
1032 if (m_pPrevTextObj) {
1033 GenerateCharacter type = ProcessInsertObject(pTextObj, form_matrix);
1034 if (type == GenerateCharacter::kLineBreak) {
1035 m_CurlineRect = pTextObj->GetRect();
1036 } else {
1037 m_CurlineRect.Union(pTextObj->GetRect());
1038 }
1039
1040 if (!ProcessGenerateCharacter(type, pTextObj, form_matrix)) {
1041 return;
1042 }
1043 } else {
1044 m_CurlineRect = pTextObj->GetRect();
1045 }
1046
1047 if (ePreMKC == MarkedContentState::kDelay) {
1048 ProcessMarkedContent(obj);
1049 m_pPrevTextObj = pTextObj;
1050 m_PrevMatrix = form_matrix;
1051 return;
1052 }
1053
1054 m_pPrevTextObj = pTextObj;
1055 m_PrevMatrix = form_matrix;
1056
1057 const bool bR2L = IsRightToLeft(*pTextObj);
1058 const CFX_Matrix matrix = pTextObj->GetTextMatrix() * form_matrix;
1059 const bool bIsBidiAndMirrorInverse =
1060 bR2L && (matrix.a * matrix.d - matrix.b * matrix.c) < 0;
1061 const size_t iBufStartAppend = m_TempTextBuf.GetLength();
1062 const size_t iCharListStartAppend = m_TempCharList.size();
1063
1064 ProcessTextObjectItems(pTextObj, form_matrix, matrix);
1065 if (bIsBidiAndMirrorInverse) {
1066 SwapTempTextBuf(iCharListStartAppend, iBufStartAppend);
1067 }
1068 }
1069
GetTextObjectWritingMode(const CPDF_TextObject * pTextObj) const1070 CPDF_TextPage::TextOrientation CPDF_TextPage::GetTextObjectWritingMode(
1071 const CPDF_TextObject* pTextObj) const {
1072 size_t nChars = pTextObj->CountChars();
1073 if (nChars <= 1)
1074 return m_TextlineDir;
1075
1076 CPDF_TextObject::Item first = pTextObj->GetCharInfo(0);
1077 CPDF_TextObject::Item last = pTextObj->GetCharInfo(nChars - 1);
1078 CFX_Matrix text_matrix = pTextObj->GetTextMatrix();
1079 first.m_Origin = text_matrix.Transform(first.m_Origin);
1080 last.m_Origin = text_matrix.Transform(last.m_Origin);
1081
1082 static constexpr float kEpsilon = 0.0001f;
1083 float dX = fabs(last.m_Origin.x - first.m_Origin.x);
1084 float dY = fabs(last.m_Origin.y - first.m_Origin.y);
1085 if (dX <= kEpsilon && dY <= kEpsilon)
1086 return TextOrientation::kUnknown;
1087
1088 static constexpr float kThreshold = 0.0872f;
1089 CFX_VectorF v(dX, dY);
1090 v.Normalize();
1091 bool bXUnderThreshold = v.x <= kThreshold;
1092 if (v.y <= kThreshold)
1093 return bXUnderThreshold ? m_TextlineDir : TextOrientation::kHorizontal;
1094 return bXUnderThreshold ? TextOrientation::kVertical : m_TextlineDir;
1095 }
1096
IsHyphen(wchar_t curChar) const1097 bool CPDF_TextPage::IsHyphen(wchar_t curChar) const {
1098 WideStringView curText = m_TempTextBuf.AsStringView();
1099 if (curText.IsEmpty())
1100 curText = m_TextBuf.AsStringView();
1101
1102 if (curText.IsEmpty())
1103 return false;
1104
1105 auto iter = curText.rbegin();
1106 for (; (iter + 1) != curText.rend() && *iter == 0x20; ++iter) {
1107 // Do nothing
1108 }
1109
1110 if (!IsHyphenCode(*iter))
1111 return false;
1112
1113 if ((iter + 1) != curText.rend()) {
1114 iter++;
1115 if (FXSYS_iswalpha(*iter) && FXSYS_iswalnum(curChar))
1116 return true;
1117 }
1118
1119 const CharInfo* pPrevCharInfo = GetPrevCharInfo();
1120 return pPrevCharInfo && pPrevCharInfo->char_type() == CharType::kPiece &&
1121 IsHyphenCode(pPrevCharInfo->unicode());
1122 }
1123
GetPrevCharInfo() const1124 const CPDF_TextPage::CharInfo* CPDF_TextPage::GetPrevCharInfo() const {
1125 if (!m_TempCharList.empty())
1126 return &m_TempCharList.back();
1127 return !m_CharList.empty() ? &m_CharList.back() : nullptr;
1128 }
1129
ProcessInsertObject(const CPDF_TextObject * pObj,const CFX_Matrix & form_matrix)1130 CPDF_TextPage::GenerateCharacter CPDF_TextPage::ProcessInsertObject(
1131 const CPDF_TextObject* pObj,
1132 const CFX_Matrix& form_matrix) {
1133 FindPreviousTextObject();
1134 TextOrientation WritingMode = GetTextObjectWritingMode(pObj);
1135 if (WritingMode == TextOrientation::kUnknown)
1136 WritingMode = GetTextObjectWritingMode(m_pPrevTextObj);
1137
1138 size_t nItem = m_pPrevTextObj->CountItems();
1139 if (nItem == 0)
1140 return GenerateCharacter::kNone;
1141
1142 CPDF_TextObject::Item PrevItem = m_pPrevTextObj->GetItemInfo(nItem - 1);
1143 CPDF_TextObject::Item item = pObj->GetItemInfo(0);
1144 const CFX_FloatRect& this_rect = pObj->GetRect();
1145 const CFX_FloatRect& prev_rect = m_pPrevTextObj->GetRect();
1146 WideString unicode = pObj->GetFont()->UnicodeFromCharCode(item.m_CharCode);
1147 if (unicode.IsEmpty()) {
1148 unicode += static_cast<wchar_t>(item.m_CharCode);
1149 }
1150
1151 wchar_t curChar = unicode[0];
1152 if (WritingMode == TextOrientation::kHorizontal) {
1153 if (EndHorizontalLine(this_rect, prev_rect)) {
1154 return IsHyphen(curChar) ? GenerateCharacter::kHyphen
1155 : GenerateCharacter::kLineBreak;
1156 }
1157 } else if (WritingMode == TextOrientation::kVertical) {
1158 if (EndVerticalLine(this_rect, prev_rect, m_CurlineRect,
1159 pObj->GetFontSize(), m_pPrevTextObj->GetFontSize())) {
1160 return IsHyphen(curChar) ? GenerateCharacter::kHyphen
1161 : GenerateCharacter::kLineBreak;
1162 }
1163 }
1164
1165 float last_pos = PrevItem.m_Origin.x;
1166 int nLastWidth =
1167 GetCharWidth(PrevItem.m_CharCode, m_pPrevTextObj->GetFont().Get());
1168 float last_width = nLastWidth * m_pPrevTextObj->GetFontSize() / 1000;
1169 last_width = fabs(last_width);
1170 int nThisWidth = GetCharWidth(item.m_CharCode, pObj->GetFont().Get());
1171 float this_width = fabs(nThisWidth * pObj->GetFontSize() / 1000);
1172 float threshold = std::max(last_width, this_width) / 4;
1173
1174 CFX_Matrix prev_matrix = m_pPrevTextObj->GetTextMatrix() * m_PrevMatrix;
1175 CFX_Matrix prev_reverse = prev_matrix.GetInverse();
1176
1177 CFX_PointF pos =
1178 prev_reverse.Transform(form_matrix.Transform(pObj->GetPos()));
1179 if (last_width < this_width)
1180 threshold = prev_reverse.TransformDistance(threshold);
1181
1182 bool bNewline = false;
1183 if (WritingMode == TextOrientation::kHorizontal) {
1184 CFX_FloatRect rect = m_pPrevTextObj->GetRect();
1185 float rect_height = rect.Height();
1186 rect.Normalize();
1187 if ((rect.IsEmpty() && rect_height > 5) ||
1188 ((pos.y > threshold * 2 || pos.y < threshold * -3) &&
1189 (fabs(pos.y) >= 1 || fabs(pos.y) > fabs(pos.x)))) {
1190 bNewline = true;
1191 if (nItem > 1) {
1192 CPDF_TextObject::Item tempItem = m_pPrevTextObj->GetItemInfo(0);
1193 CFX_Matrix m = m_pPrevTextObj->GetTextMatrix();
1194 if (PrevItem.m_Origin.x > tempItem.m_Origin.x &&
1195 m_DisplayMatrix.a > 0.9 && m_DisplayMatrix.b < 0.1 &&
1196 m_DisplayMatrix.c < 0.1 && m_DisplayMatrix.d < -0.9 && m.b < 0.1 &&
1197 m.c < 0.1) {
1198 CFX_FloatRect re(0, m_pPrevTextObj->GetRect().bottom, 1000,
1199 m_pPrevTextObj->GetRect().top);
1200 if (re.Contains(pObj->GetPos())) {
1201 bNewline = false;
1202 } else {
1203 if (CFX_FloatRect(0, pObj->GetRect().bottom, 1000,
1204 pObj->GetRect().top)
1205 .Contains(m_pPrevTextObj->GetPos())) {
1206 bNewline = false;
1207 }
1208 }
1209 }
1210 }
1211 }
1212 }
1213 if (bNewline) {
1214 return IsHyphen(curChar) ? GenerateCharacter::kHyphen
1215 : GenerateCharacter::kLineBreak;
1216 }
1217
1218 if (pObj->CountChars() == 1 && IsHyphenCode(curChar) && IsHyphen(curChar))
1219 return GenerateCharacter::kHyphen;
1220
1221 if (curChar == L' ')
1222 return GenerateCharacter::kNone;
1223
1224 WideString PrevStr =
1225 m_pPrevTextObj->GetFont()->UnicodeFromCharCode(PrevItem.m_CharCode);
1226 wchar_t preChar = PrevStr.Back();
1227 if (preChar == L' ')
1228 return GenerateCharacter::kNone;
1229
1230 CFX_Matrix matrix = pObj->GetTextMatrix() * form_matrix;
1231 float threshold2 = std::max(nLastWidth, nThisWidth);
1232 threshold2 = NormalizeThreshold(threshold2, 400, 700, 800);
1233 if (nLastWidth >= nThisWidth) {
1234 threshold2 *= fabs(m_pPrevTextObj->GetFontSize());
1235 } else {
1236 threshold2 *= fabs(pObj->GetFontSize());
1237 threshold2 = matrix.TransformDistance(threshold2);
1238 threshold2 = prev_reverse.TransformDistance(threshold2);
1239 }
1240 threshold2 /= 1000;
1241 if ((threshold2 < 1.4881 && threshold2 > 1.4879) ||
1242 (threshold2 < 1.39001 && threshold2 > 1.38999)) {
1243 threshold2 *= 1.5;
1244 }
1245 return GenerateSpace(pos, last_pos, this_width, last_width, threshold2)
1246 ? GenerateCharacter::kSpace
1247 : GenerateCharacter::kNone;
1248 }
1249
ProcessGenerateCharacter(GenerateCharacter type,const CPDF_TextObject * text_object,const CFX_Matrix & form_matrix)1250 bool CPDF_TextPage::ProcessGenerateCharacter(GenerateCharacter type,
1251 const CPDF_TextObject* text_object,
1252 const CFX_Matrix& form_matrix) {
1253 switch (type) {
1254 case GenerateCharacter::kNone:
1255 return true;
1256 case GenerateCharacter::kSpace: {
1257 AppendGeneratedCharacter(L' ', form_matrix, /*use_temp_buffer=*/true);
1258 return true;
1259 }
1260 case GenerateCharacter::kLineBreak:
1261 CloseTempLine();
1262 if (m_TextBuf.GetSize()) {
1263 AppendGeneratedCharacter(L'\r', form_matrix, /*use_temp_buffer=*/false);
1264 AppendGeneratedCharacter(L'\n', form_matrix, /*use_temp_buffer=*/false);
1265 }
1266 return true;
1267 case GenerateCharacter::kHyphen:
1268 if (text_object->CountChars() == 1) {
1269 CPDF_TextObject::Item item = text_object->GetCharInfo(0);
1270 WideString unicode =
1271 text_object->GetFont()->UnicodeFromCharCode(item.m_CharCode);
1272 if (unicode.IsEmpty()) {
1273 unicode += static_cast<wchar_t>(item.m_CharCode);
1274 }
1275 wchar_t curChar = unicode[0];
1276 if (IsHyphenCode(curChar)) {
1277 return false;
1278 }
1279 }
1280 while (m_TempTextBuf.GetSize() > 0 &&
1281 m_TempTextBuf.AsStringView().Back() == 0x20) {
1282 m_TempTextBuf.Delete(m_TempTextBuf.GetLength() - 1, 1);
1283 m_TempCharList.pop_back();
1284 }
1285 CharInfo& charinfo = m_TempCharList.back();
1286 m_TempTextBuf.Delete(m_TempTextBuf.GetLength() - 1, 1);
1287 charinfo.set_char_type(CharType::kHyphen);
1288 charinfo.set_unicode(0x2);
1289 m_TempTextBuf.AppendChar(0xfffe);
1290 return true;
1291 }
1292 NOTREACHED_NORETURN();
1293 }
1294
ProcessTextObjectItems(CPDF_TextObject * text_object,const CFX_Matrix & form_matrix,const CFX_Matrix & matrix)1295 void CPDF_TextPage::ProcessTextObjectItems(CPDF_TextObject* text_object,
1296 const CFX_Matrix& form_matrix,
1297 const CFX_Matrix& matrix) {
1298 const float base_space = CalculateBaseSpace(text_object, matrix) +
1299 CalculateBaseSpaceAdjustment(text_object, matrix);
1300 RetainPtr<CPDF_Font> const font = text_object->GetFont();
1301
1302 float spacing = 0;
1303 const size_t nItems = text_object->CountItems();
1304 for (size_t i = 0; i < nItems; ++i) {
1305 CPDF_TextObject::Item item = text_object->GetItemInfo(i);
1306 if (item.m_CharCode == 0xffffffff) {
1307 WideString str = m_TempTextBuf.MakeString();
1308 if (str.IsEmpty()) {
1309 str = m_TextBuf.AsStringView();
1310 }
1311 if (!str.IsEmpty() && str.Back() != L' ') {
1312 float fontsize_h = text_object->text_state().GetFontSizeH();
1313 spacing = -fontsize_h * item.m_Origin.x / 1000;
1314 }
1315 continue;
1316 }
1317
1318 spacing -= base_space;
1319
1320 if (spacing && i > 0) {
1321 const float threshold = CalculateSpaceThreshold(
1322 font, text_object->text_state().GetFontSizeH(), item.m_CharCode);
1323 if (threshold && spacing && spacing >= threshold) {
1324 m_TempTextBuf.AppendChar(L' ');
1325 CFX_PointF origin = matrix.Transform(item.m_Origin);
1326 m_TempCharList.push_back(CharInfo(
1327 CharType::kGenerated, CPDF_Font::kInvalidCharCode, L' ', origin,
1328 CFX_FloatRect(origin.x, origin.y, origin.x, origin.y), form_matrix,
1329 text_object));
1330 }
1331 if (item.m_CharCode == CPDF_Font::kInvalidCharCode) {
1332 continue;
1333 }
1334 }
1335
1336 spacing = 0;
1337 WideString unicode = font->UnicodeFromCharCode(item.m_CharCode);
1338 CharType char_type = CharType::kNormal;
1339 if (unicode.IsEmpty() && item.m_CharCode) {
1340 unicode += static_cast<wchar_t>(item.m_CharCode);
1341 char_type = CharType::kNotUnicode;
1342 }
1343
1344 const FX_RECT rect = font->GetCharBBox(item.m_CharCode);
1345 const float fFontSize = text_object->GetFontSize() / 1000;
1346 CFX_FloatRect char_box(rect.left * fFontSize + item.m_Origin.x,
1347 rect.bottom * fFontSize + item.m_Origin.y,
1348 rect.right * fFontSize + item.m_Origin.x,
1349 rect.top * fFontSize + item.m_Origin.y);
1350 if (fabsf(char_box.top - char_box.bottom) < kSizeEpsilon) {
1351 char_box.top = char_box.bottom + fFontSize;
1352 }
1353 if (fabsf(char_box.right - char_box.left) < kSizeEpsilon) {
1354 char_box.right =
1355 char_box.left + text_object->GetCharWidth(item.m_CharCode);
1356 }
1357 char_box = matrix.TransformRect(char_box);
1358
1359 CharInfo charinfo(char_type, item.m_CharCode, 0,
1360 matrix.Transform(item.m_Origin), char_box, matrix,
1361 text_object);
1362 if (unicode.IsEmpty()) {
1363 m_TempCharList.push_back(charinfo);
1364 m_TempTextBuf.AppendChar(0xfffe);
1365 continue;
1366 }
1367
1368 bool add_unicode = true;
1369 const int count = std::min(fxcrt::CollectionSize<int>(m_TempCharList), 7);
1370 constexpr float kTextCharRatioGapDelta = 0.07f;
1371 float threshold = charinfo.matrix().TransformXDistance(
1372 kTextCharRatioGapDelta * text_object->GetFontSize());
1373 for (int n = fxcrt::CollectionSize<int>(m_TempCharList);
1374 n > fxcrt::CollectionSize<int>(m_TempCharList) - count; --n) {
1375 const CharInfo& charinfo1 = m_TempCharList[n - 1];
1376 CFX_PointF diff = charinfo1.origin() - charinfo.origin();
1377 if (charinfo1.char_code() == charinfo.char_code() &&
1378 charinfo1.text_object()->GetFont() ==
1379 charinfo.text_object()->GetFont() &&
1380 fabs(diff.x) < threshold && fabs(diff.y) < threshold) {
1381 add_unicode = false;
1382 break;
1383 }
1384 }
1385 if (add_unicode) {
1386 for (wchar_t c : unicode) {
1387 charinfo.set_unicode(c);
1388 m_TempTextBuf.AppendChar(c ? c : 0xfffe);
1389 m_TempCharList.push_back(charinfo);
1390 }
1391 } else if (i == 0) {
1392 WideString str = m_TempTextBuf.MakeString();
1393 if (!str.IsEmpty() && str.Back() == L' ') {
1394 m_TempTextBuf.Delete(m_TempTextBuf.GetLength() - 1, 1);
1395 m_TempCharList.pop_back();
1396 }
1397 }
1398 }
1399 }
1400
IsSameTextObject(CPDF_TextObject * pTextObj1,CPDF_TextObject * pTextObj2) const1401 bool CPDF_TextPage::IsSameTextObject(CPDF_TextObject* pTextObj1,
1402 CPDF_TextObject* pTextObj2) const {
1403 if (!pTextObj1 || !pTextObj2)
1404 return false;
1405
1406 CFX_FloatRect rcPreObj = pTextObj2->GetRect();
1407 const CFX_FloatRect& rcCurObj = pTextObj1->GetRect();
1408 if (rcPreObj.IsEmpty() && rcCurObj.IsEmpty()) {
1409 float dbXdif = fabs(rcPreObj.left - rcCurObj.left);
1410 size_t nCount = m_CharList.size();
1411 if (nCount >= 2) {
1412 float dbSpace = m_CharList[nCount - 2].char_box().Width();
1413 if (dbXdif > dbSpace)
1414 return false;
1415 }
1416 }
1417 if (!rcPreObj.IsEmpty() || !rcCurObj.IsEmpty()) {
1418 rcPreObj.Intersect(rcCurObj);
1419 if (rcPreObj.IsEmpty())
1420 return false;
1421 if (fabs(rcPreObj.Width() - rcCurObj.Width()) > rcCurObj.Width() / 2) {
1422 return false;
1423 }
1424 if (pTextObj2->GetFontSize() != pTextObj1->GetFontSize())
1425 return false;
1426 }
1427
1428 size_t nPreCount = pTextObj2->CountItems();
1429 if (nPreCount != pTextObj1->CountItems())
1430 return false;
1431
1432 // If both objects have no items, consider them same.
1433 if (nPreCount == 0)
1434 return true;
1435
1436 CPDF_TextObject::Item itemPer;
1437 CPDF_TextObject::Item itemCur;
1438 for (size_t i = 0; i < nPreCount; ++i) {
1439 itemPer = pTextObj2->GetItemInfo(i);
1440 itemCur = pTextObj1->GetItemInfo(i);
1441 if (itemCur.m_CharCode != itemPer.m_CharCode)
1442 return false;
1443 }
1444
1445 CFX_PointF diff = pTextObj1->GetPos() - pTextObj2->GetPos();
1446 float font_size = pTextObj2->GetFontSize();
1447 float char_size =
1448 GetCharWidth(itemPer.m_CharCode, pTextObj2->GetFont().Get());
1449 float max_pre_size =
1450 std::max(std::max(rcPreObj.Height(), rcPreObj.Width()), font_size);
1451 return fabs(diff.x) <= 0.9 * char_size * font_size / 1000 &&
1452 fabs(diff.y) <= max_pre_size / 8;
1453 }
1454
IsSameAsPreTextObject(CPDF_TextObject * pTextObj,const CPDF_PageObjectHolder * pObjList,CPDF_PageObjectHolder::const_iterator iter) const1455 bool CPDF_TextPage::IsSameAsPreTextObject(
1456 CPDF_TextObject* pTextObj,
1457 const CPDF_PageObjectHolder* pObjList,
1458 CPDF_PageObjectHolder::const_iterator iter) const {
1459 int i = 0;
1460 while (i < 5 && iter != pObjList->begin()) {
1461 --iter;
1462 CPDF_PageObject* pOtherObj = iter->get();
1463 if (pOtherObj == pTextObj || !pOtherObj->IsText())
1464 continue;
1465 if (IsSameTextObject(pOtherObj->AsText(), pTextObj))
1466 return true;
1467 ++i;
1468 }
1469 return false;
1470 }
1471
GenerateCharInfo(wchar_t unicode,const CFX_Matrix & form_matrix)1472 std::optional<CPDF_TextPage::CharInfo> CPDF_TextPage::GenerateCharInfo(
1473 wchar_t unicode,
1474 const CFX_Matrix& form_matrix) {
1475 const CharInfo* pPrevCharInfo = GetPrevCharInfo();
1476 if (!pPrevCharInfo) {
1477 return std::nullopt;
1478 }
1479
1480 int pre_width = 0;
1481 if (pPrevCharInfo->text_object() &&
1482 pPrevCharInfo->char_code() != CPDF_Font::kInvalidCharCode) {
1483 pre_width = GetCharWidth(pPrevCharInfo->char_code(),
1484 pPrevCharInfo->text_object()->GetFont().Get());
1485 }
1486
1487 float fFontSize = pPrevCharInfo->text_object()
1488 ? pPrevCharInfo->text_object()->GetFontSize()
1489 : pPrevCharInfo->char_box().Height();
1490 if (!fFontSize)
1491 fFontSize = kDefaultFontSize;
1492
1493 CFX_PointF origin(pPrevCharInfo->origin().x + pre_width * (fFontSize) / 1000,
1494 pPrevCharInfo->origin().y);
1495 return CharInfo(CharType::kGenerated, CPDF_Font::kInvalidCharCode, unicode,
1496 origin, CFX_FloatRect(origin.x, origin.y, origin.x, origin.y),
1497 form_matrix, /*text_object=*/nullptr);
1498 }
1499