Do some IWYU cleanups.
[pdfium.git] / core / src / fpdftext / fpdf_text.cpp
1 // Copyright 2014 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 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
6
7 #include "../../include/fpdfapi/fpdf_page.h"
8 #include "../../include/fpdfapi/fpdf_pageobj.h"
9 #include "../../include/fpdftext/fpdf_text.h"
10 #include "../../include/fxcrt/fx_arb.h"
11 #include "../../include/fxcrt/fx_ucd.h"
12 #include "text_int.h"
13 #include "txtproc.h"
14
15 extern const FX_CHAR* FCS_GetAltStr(FX_WCHAR);
16 CFX_ByteString CharFromUnicodeAlt(FX_WCHAR unicode, int destcp, const FX_CHAR* defchar)
17 {
18     if (destcp == 0) {
19         if (unicode < 0x80) {
20             return CFX_ByteString((char)unicode);
21         }
22         const FX_CHAR* altstr = FCS_GetAltStr(unicode);
23         if (altstr) {
24             return CFX_ByteString(altstr, -1);
25         }
26         return CFX_ByteString(defchar, -1);
27     }
28     FX_BOOL bDef = FALSE;
29     char buf[10];
30     int ret = FXSYS_WideCharToMultiByte(destcp, 0, (wchar_t*)&unicode, 1, buf, 10, NULL, &bDef);
31     if (ret && !bDef) {
32         return CFX_ByteString(buf, ret);
33     }
34     const FX_CHAR* altstr = FCS_GetAltStr(unicode);
35     if (altstr) {
36         return CFX_ByteString(altstr, -1);
37     }
38     return CFX_ByteString(defchar, -1);
39 }
40 CTextPage::CTextPage()
41 {
42 }
43 CTextPage::~CTextPage()
44 {
45     int i;
46     for (i = 0; i < m_BaseLines.GetSize(); i ++) {
47         CTextBaseLine* pBaseLine = (CTextBaseLine*)m_BaseLines.GetAt(i);
48         delete pBaseLine;
49     }
50     for (i = 0; i < m_TextColumns.GetSize(); i ++) {
51         CTextColumn* pTextColumn = (CTextColumn*)m_TextColumns.GetAt(i);
52         delete pTextColumn;
53     }
54 }
55 void CTextPage::ProcessObject(CPDF_PageObject* pObject)
56 {
57     if (pObject->m_Type != PDFPAGE_TEXT) {
58         return;
59     }
60     CPDF_TextObject* pText = (CPDF_TextObject*)pObject;
61     CPDF_Font* pFont = pText->m_TextState.GetFont();
62     int count = pText->CountItems();
63     FX_FLOAT* pPosArray = FX_Alloc2D(FX_FLOAT, count, 2);
64     pText->CalcCharPos(pPosArray);
65
66     FX_FLOAT fontsize_h = pText->m_TextState.GetFontSizeH();
67     FX_FLOAT fontsize_v = pText->m_TextState.GetFontSizeV();
68     FX_DWORD space_charcode = pFont->CharCodeFromUnicode(' ');
69     FX_FLOAT spacew = 0;
70     if (space_charcode != -1) {
71         spacew = fontsize_h * pFont->GetCharWidthF(space_charcode) / 1000;
72     }
73     if (spacew == 0) {
74         spacew = fontsize_h / 4;
75     }
76     if (pText->m_TextState.GetBaselineAngle() != 0) {
77         int cc = 0;
78         CFX_AffineMatrix matrix;
79         pText->GetTextMatrix(&matrix);
80         for (int i = 0; i < pText->m_nChars; i ++) {
81             FX_DWORD charcode = pText->m_nChars == 1 ? (FX_DWORD)(uintptr_t)pText->m_pCharCodes : pText->m_pCharCodes[i];
82             if (charcode == (FX_DWORD) - 1) {
83                 continue;
84             }
85             FX_RECT char_box;
86             pFont->GetCharBBox(charcode, char_box);
87             FX_FLOAT char_left = pPosArray ? pPosArray[cc * 2] : char_box.left * pText->m_TextState.GetFontSize() / 1000;
88             FX_FLOAT char_right = pPosArray ? pPosArray[cc * 2 + 1] : char_box.right * pText->m_TextState.GetFontSize() / 1000;
89             FX_FLOAT char_top = char_box.top * pText->m_TextState.GetFontSize() / 1000;
90             FX_FLOAT char_bottom = char_box.bottom * pText->m_TextState.GetFontSize() / 1000;
91             cc ++;
92             FX_FLOAT char_origx, char_origy;
93             matrix.Transform(char_left, 0, char_origx, char_origy);
94             matrix.TransformRect(char_left, char_right, char_top, char_bottom);
95             CFX_ByteString str;
96             pFont->AppendChar(str, charcode);
97             InsertTextBox(NULL, char_origy, char_left, char_right, char_top,
98                           char_bottom, spacew, fontsize_v, str, pFont);
99         }
100         if (pPosArray) {
101             FX_Free(pPosArray);
102         }
103         return;
104     }
105     FX_FLOAT ratio_h = fontsize_h / pText->m_TextState.GetFontSize();
106     for (int ii = 0; ii < count * 2; ii ++) {
107         pPosArray[ii] *= ratio_h;
108     }
109     FX_FLOAT baseline = pText->m_PosY;
110     CTextBaseLine* pBaseLine = NULL;
111     FX_FLOAT topy = pText->m_Top;
112     FX_FLOAT bottomy = pText->m_Bottom;
113     FX_FLOAT leftx = pText->m_Left;
114     int cc = 0;
115     CFX_ByteString segment;
116     int space_count = 0;
117     FX_FLOAT last_left = 0, last_right = 0, segment_left = 0, segment_right = 0;
118     for (int i = 0; i < pText->m_nChars; i ++) {
119         FX_DWORD charcode = pText->m_nChars == 1 ? (FX_DWORD)(uintptr_t)pText->m_pCharCodes : pText->m_pCharCodes[i];
120         if (charcode == (FX_DWORD) - 1) {
121             continue;
122         }
123         FX_FLOAT char_left = pPosArray[cc * 2];
124         FX_FLOAT char_right = pPosArray[cc * 2 + 1];
125         cc ++;
126         if (char_left < last_left || (char_left - last_right) > spacew / 2) {
127             pBaseLine = InsertTextBox(pBaseLine, baseline, leftx + segment_left, leftx + segment_right,
128                                       topy, bottomy, spacew, fontsize_v, segment, pFont);
129             segment_left = char_left;
130             segment = "";
131         }
132         if (space_count > 1) {
133             pBaseLine = InsertTextBox(pBaseLine, baseline, leftx + segment_left, leftx + segment_right,
134                                       topy, bottomy, spacew, fontsize_v, segment, pFont);
135             segment = "";
136         } else if (space_count == 1) {
137             pFont->AppendChar(segment, ' ');
138         }
139         if (segment.GetLength() == 0) {
140             segment_left = char_left;
141         }
142         segment_right = char_right;
143         pFont->AppendChar(segment, charcode);
144         space_count = 0;
145         last_left = char_left;
146         last_right = char_right;
147     }
148     if (segment.GetLength())
149         pBaseLine = InsertTextBox(pBaseLine, baseline, leftx + segment_left, leftx + segment_right,
150                                   topy, bottomy, spacew, fontsize_v, segment, pFont);
151     FX_Free(pPosArray);
152 }
153 CTextBaseLine* CTextPage::InsertTextBox(CTextBaseLine* pBaseLine, FX_FLOAT basey, FX_FLOAT leftx,
154                                         FX_FLOAT rightx, FX_FLOAT topy, FX_FLOAT bottomy, FX_FLOAT spacew, FX_FLOAT fontsize_v,
155                                         CFX_ByteString& str, CPDF_Font* pFont)
156 {
157     if (str.GetLength() == 0) {
158         return NULL;
159     }
160     if (pBaseLine == NULL) {
161         int i;
162         for (i = 0; i < m_BaseLines.GetSize(); i ++) {
163             CTextBaseLine* pExistLine = (CTextBaseLine*)m_BaseLines.GetAt(i);
164             if (pExistLine->m_BaseLine == basey) {
165                 pBaseLine = pExistLine;
166                 break;
167             }
168             if (pExistLine->m_BaseLine < basey) {
169                 break;
170             }
171         }
172         if (pBaseLine == NULL) {
173             pBaseLine = new CTextBaseLine;
174             pBaseLine->m_BaseLine = basey;
175             m_BaseLines.InsertAt(i, pBaseLine);
176         }
177     }
178     CFX_WideString text;
179     const FX_CHAR* pStr = str;
180     int len = str.GetLength(), offset = 0;
181     while (offset < len) {
182         FX_DWORD ch = pFont->GetNextChar(pStr, len, offset);
183         CFX_WideString unicode_str = pFont->UnicodeFromCharCode(ch);
184         if (unicode_str.IsEmpty()) {
185             text += (FX_WCHAR)ch;
186         }
187         else {
188             text += unicode_str;
189         }
190     }
191     pBaseLine->InsertTextBox(leftx, rightx, topy, bottomy, spacew, fontsize_v, text);
192     return pBaseLine;
193 }
194 void CTextPage::WriteOutput(CFX_WideStringArray& lines, int iMinWidth)
195 {
196     FX_FLOAT lastheight = -1;
197     FX_FLOAT lastbaseline = -1;
198     FX_FLOAT MinLeftX = 1000000;
199     FX_FLOAT MaxRightX = 0;
200     int i;
201     for (i = 0; i < m_BaseLines.GetSize(); i ++) {
202         CTextBaseLine* pBaseLine = (CTextBaseLine*)m_BaseLines.GetAt(i);
203         FX_FLOAT leftx, rightx;
204         if (pBaseLine->GetWidth(leftx, rightx)) {
205             if (leftx < MinLeftX) {
206                 MinLeftX = leftx;
207             }
208             if (rightx > MaxRightX) {
209                 MaxRightX = rightx;
210             }
211         }
212     }
213     for (i = 0; i < m_BaseLines.GetSize(); i ++) {
214         CTextBaseLine* pBaseLine = (CTextBaseLine*)m_BaseLines.GetAt(i);
215         pBaseLine->MergeBoxes();
216     }
217     for (i = 1; i < m_BaseLines.GetSize(); i ++) {
218         CTextBaseLine* pBaseLine = (CTextBaseLine*)m_BaseLines.GetAt(i);
219         CTextBaseLine* pPrevLine = (CTextBaseLine*)m_BaseLines.GetAt(i - 1);
220         if (pBaseLine->CanMerge(pPrevLine)) {
221             pPrevLine->Merge(pBaseLine);
222             delete pBaseLine;
223             m_BaseLines.RemoveAt(i);
224             i --;
225         }
226     }
227     if (m_bAutoWidth) {
228         int* widths = FX_Alloc(int, m_BaseLines.GetSize());
229         for (i = 0; i < m_BaseLines.GetSize(); i ++) {
230             widths[i] = 0;
231             CTextBaseLine* pBaseLine = (CTextBaseLine*)m_BaseLines.GetAt(i);
232             int TotalChars = 0;
233             FX_FLOAT TotalWidth = 0;
234             int minchars;
235             pBaseLine->CountChars(TotalChars, TotalWidth, minchars);
236             if (TotalChars) {
237                 FX_FLOAT charwidth = TotalWidth / TotalChars;
238                 widths[i] = (int)((MaxRightX - MinLeftX) / charwidth);
239             }
240             if (widths[i] > 1000) {
241                 widths[i] = 1000;
242             }
243             if (widths[i] < minchars) {
244                 widths[i] = minchars;
245             }
246         }
247         int AvgWidth = 0, widthcount = 0;
248         for (i = 0; i < m_BaseLines.GetSize(); i ++)
249             if (widths[i]) {
250                 AvgWidth += widths[i];
251                 widthcount ++;
252             }
253         AvgWidth = int((FX_FLOAT)AvgWidth / widthcount + 0.5);
254         int MaxWidth = 0;
255         for (i = 0; i < m_BaseLines.GetSize(); i ++)
256             if (MaxWidth < widths[i]) {
257                 MaxWidth = widths[i];
258             }
259         if (MaxWidth > AvgWidth * 6 / 5) {
260             MaxWidth = AvgWidth * 6 / 5;
261         }
262         FX_Free(widths);
263         if (iMinWidth < MaxWidth) {
264             iMinWidth = MaxWidth;
265         }
266     }
267     for (i = 0; i < m_BaseLines.GetSize(); i ++) {
268         CTextBaseLine* pBaseLine = (CTextBaseLine*)m_BaseLines.GetAt(i);
269         pBaseLine->MergeBoxes();
270     }
271     if (m_bKeepColumn) {
272         FindColumns();
273     }
274     for (i = 0; i < m_BaseLines.GetSize(); i ++) {
275         CTextBaseLine* pBaseLine = (CTextBaseLine*)m_BaseLines.GetAt(i);
276         if (lastheight >= 0) {
277             FX_FLOAT dy = lastbaseline - pBaseLine->m_BaseLine;
278             if (dy >= (pBaseLine->m_MaxFontSizeV) * 1.5 || dy >= lastheight * 1.5) {
279                 lines.Add(L"");
280             }
281         }
282         lastheight = pBaseLine->m_MaxFontSizeV;
283         lastbaseline = pBaseLine->m_BaseLine;
284         CFX_WideString str;
285         pBaseLine->WriteOutput(str, MinLeftX, MaxRightX - MinLeftX, iMinWidth);
286         lines.Add(str);
287     }
288 }
289 void NormalizeCompositeChar(FX_WCHAR wChar, CFX_WideString& sDest)
290 {
291     wChar = FX_GetMirrorChar(wChar, TRUE, FALSE);
292     FX_WCHAR* pDst = NULL;
293     FX_STRSIZE nCount = FX_Unicode_GetNormalization(wChar, pDst);
294     if (nCount < 1 ) {
295         sDest += wChar;
296         return;
297     }
298     pDst = new FX_WCHAR[nCount];
299     FX_Unicode_GetNormalization(wChar, pDst);
300     for (int nIndex = 0; nIndex < nCount; nIndex++) {
301         sDest += pDst[nIndex];
302     }
303     delete[] pDst;
304 }
305 void NormalizeString(CFX_WideString& str)
306 {
307     if (str.GetLength() <= 0) {
308         return;
309     }
310     CFX_WideString sBuffer;
311     IFX_BidiChar* BidiChar = IFX_BidiChar::Create();
312     if (NULL == BidiChar)       {
313         return;
314     }
315     CFX_WordArray order;
316     FX_BOOL bR2L = FALSE;
317     int32_t start = 0, count = 0, i = 0;
318     int nR2L = 0, nL2R = 0;
319     for (i = 0; i < str.GetLength(); i++) {
320         if(BidiChar->AppendChar(str.GetAt(i))) {
321             int32_t ret = BidiChar->GetBidiInfo(start, count);
322             order.Add(start);
323             order.Add(count);
324             order.Add(ret);
325             if(!bR2L) {
326                 if(ret == 2) {
327                     nR2L++;
328                 } else if (ret == 1) {
329                     nL2R++;
330                 }
331             }
332         }
333     }
334     if(BidiChar->EndChar()) {
335         int32_t ret = BidiChar->GetBidiInfo(start, count);
336         order.Add(start);
337         order.Add(count);
338         order.Add(ret);
339         if(!bR2L) {
340             if(ret == 2) {
341                 nR2L++;
342             } else if(ret == 1) {
343                 nL2R++;
344             }
345         }
346     }
347     if(nR2L > 0 && nR2L >= nL2R) {
348         bR2L = TRUE;
349     }
350     if(bR2L) {
351         int count = order.GetSize();
352         for(int j = count - 1; j > 0; j -= 3) {
353             int ret = order.GetAt(j);
354             int start = order.GetAt(j - 2);
355             int count1 = order.GetAt(j - 1);
356             if(ret == 2 || ret == 0) {
357                 for(int i = start + count1 - 1; i >= start; i--) {
358                     NormalizeCompositeChar(str[i], sBuffer);
359                 }
360             } else {
361                 i = j;
362                 FX_BOOL bSymbol = FALSE;
363                 while(i > 0 && order.GetAt(i) != 2) {
364                     bSymbol = !order.GetAt(i);
365                     i -= 3;
366                 }
367                 int end = start + count1 ;
368                 int n = 0;
369                 if(bSymbol) {
370                     n = i + 6;
371                 } else {
372                     n = i + 3;
373                 }
374                 if(n >= j) {
375                     for(int m = start; m < end; m++) {
376                         sBuffer += str[m];
377                     }
378                 } else {
379                     i = j;
380                     j = n;
381                     for(; n <= i; n += 3) {
382                         int start = order.GetAt(n - 2);
383                         int count1 = order.GetAt(n - 1);
384                         int end = start + count1 ;
385                         for(int m = start; m < end; m++) {
386                             sBuffer += str[m];
387                         }
388                     }
389                 }
390             }
391         }
392     } else {
393         int count = order.GetSize();
394         FX_BOOL bL2R = FALSE;
395         for(int j = 0; j < count; j += 3) {
396             int ret = order.GetAt(j + 2);
397             int start = order.GetAt(j);
398             int count1 = order.GetAt(j + 1);
399             if(ret == 2 || (j == 0 && ret == 0 && !bL2R)) {
400                 int i = j + 3;
401                 while(bR2L && i < count) {
402                     if(order.GetAt(i + 2) == 1) {
403                         break;
404                     } else {
405                         i += 3;
406                     }
407                 }
408                 if(i == 3) {
409                     j = -3;
410                     bL2R = TRUE;
411                     continue;
412                 }
413                 int end = str.GetLength() - 1;
414                 if(i < count) {
415                     end = order.GetAt(i) - 1;
416                 }
417                 j = i - 3;
418                 for(int n = end; n >= start; n--) {
419                     NormalizeCompositeChar(str[i], sBuffer);
420                 }
421             } else {
422                 int end = start + count1 ;
423                 for(int i = start; i < end; i++) {
424                     sBuffer += str[i];
425                 }
426             }
427         }
428     }
429     str.Empty();
430     str += sBuffer;
431     BidiChar->Release();
432 }
433 static FX_BOOL IsNumber(CFX_WideString& str)
434 {
435     for (int i = 0; i < str.GetLength(); i ++) {
436         FX_WCHAR ch = str[i];
437         if ((ch < '0' || ch > '9') && ch != '-' && ch != '+' && ch != '.' && ch != ' ') {
438             return FALSE;
439         }
440     }
441     return TRUE;
442 }
443 void CTextPage::FindColumns()
444 {
445     int i;
446     for (i = 0; i < m_BaseLines.GetSize(); i ++) {
447         CTextBaseLine* pBaseLine = (CTextBaseLine*)m_BaseLines.GetAt(i);
448         for (int j = 0; j < pBaseLine->m_TextList.GetSize(); j ++) {
449             CTextBox* pTextBox = (CTextBox*)pBaseLine->m_TextList.GetAt(j);
450             CTextColumn* pColumn = FindColumn(pTextBox->m_Right);
451             if (pColumn == NULL) {
452                 pColumn = new CTextColumn;
453                 pColumn->m_Count = 1;
454                 pColumn->m_AvgPos = pTextBox->m_Right;
455                 pColumn->m_TextPos = -1;
456                 m_TextColumns.Add(pColumn);
457             } else {
458                 pColumn->m_AvgPos = (pColumn->m_Count * pColumn->m_AvgPos + pTextBox->m_Right) /
459                                     (pColumn->m_Count + 1);
460                 pColumn->m_Count ++;
461             }
462         }
463     }
464     int mincount = m_BaseLines.GetSize() / 4;
465     for (i = 0; i < m_TextColumns.GetSize(); i ++) {
466         CTextColumn* pTextColumn = (CTextColumn*)m_TextColumns.GetAt(i);
467         if (pTextColumn->m_Count >= mincount) {
468             continue;
469         }
470         delete pTextColumn;
471         m_TextColumns.RemoveAt(i);
472         i --;
473     }
474     for (i = 0; i < m_BaseLines.GetSize(); i ++) {
475         CTextBaseLine* pBaseLine = (CTextBaseLine*)m_BaseLines.GetAt(i);
476         for (int j = 0; j < pBaseLine->m_TextList.GetSize(); j ++) {
477             CTextBox* pTextBox = (CTextBox*)pBaseLine->m_TextList.GetAt(j);
478             if (IsNumber(pTextBox->m_Text)) {
479                 pTextBox->m_pColumn = FindColumn(pTextBox->m_Right);
480             }
481         }
482     }
483 }
484 CTextColumn* CTextPage::FindColumn(FX_FLOAT xpos)
485 {
486     for (int i = 0; i < m_TextColumns.GetSize(); i ++) {
487         CTextColumn* pColumn = (CTextColumn*)m_TextColumns.GetAt(i);
488         if (pColumn->m_AvgPos < xpos + 1 && pColumn->m_AvgPos > xpos - 1) {
489             return pColumn;
490         }
491     }
492     return NULL;
493 }
494 void CTextPage::BreakSpace(CPDF_TextObject* pTextObj)
495 {
496 }
497 CTextBaseLine::CTextBaseLine()
498 {
499     m_Top = -100000;
500     m_Bottom = 100000;
501     m_MaxFontSizeV = 0;
502 }
503 CTextBaseLine::~CTextBaseLine()
504 {
505     for (int i = 0; i < m_TextList.GetSize(); i ++) {
506         CTextBox* pText = (CTextBox*)m_TextList.GetAt(i);
507         delete pText;
508     }
509 }
510 void CTextBaseLine::InsertTextBox(FX_FLOAT leftx, FX_FLOAT rightx, FX_FLOAT topy, FX_FLOAT bottomy,
511                                   FX_FLOAT spacew, FX_FLOAT fontsize_v, const CFX_WideString& text)
512 {
513     if (m_Top < topy) {
514         m_Top = topy;
515     }
516     if (m_Bottom > bottomy) {
517         m_Bottom = bottomy;
518     }
519     if (m_MaxFontSizeV < fontsize_v) {
520         m_MaxFontSizeV = fontsize_v;
521     }
522     int i;
523     for (i = 0; i < m_TextList.GetSize(); i ++) {
524         CTextBox* pText = (CTextBox*)m_TextList.GetAt(i);
525         if (pText->m_Left > leftx) {
526             break;
527         }
528     }
529     CTextBox* pText = new CTextBox;
530     pText->m_Text = text;
531     pText->m_Left = leftx;
532     pText->m_Right = rightx;
533     pText->m_Top = topy;
534     pText->m_Bottom = bottomy;
535     pText->m_SpaceWidth = spacew;
536     pText->m_FontSizeV = fontsize_v;
537     pText->m_pColumn = NULL;
538     m_TextList.InsertAt(i, pText);
539 }
540 FX_BOOL GetIntersection(FX_FLOAT low1, FX_FLOAT high1, FX_FLOAT low2, FX_FLOAT high2,
541                         FX_FLOAT& interlow, FX_FLOAT& interhigh);
542 FX_BOOL CTextBaseLine::CanMerge(CTextBaseLine* pOther)
543 {
544     FX_FLOAT inter_top, inter_bottom;
545     if (!GetIntersection(m_Bottom, m_Top, pOther->m_Bottom, pOther->m_Top,
546                          inter_bottom, inter_top)) {
547         return FALSE;
548     }
549     FX_FLOAT inter_h = inter_top - inter_bottom;
550     if (inter_h < (m_Top - m_Bottom) / 2 && inter_h < (pOther->m_Top - pOther->m_Bottom) / 2) {
551         return FALSE;
552     }
553     FX_FLOAT dy = (FX_FLOAT)FXSYS_fabs(m_BaseLine - pOther->m_BaseLine);
554     for (int i = 0; i < m_TextList.GetSize(); i ++) {
555         CTextBox* pText = (CTextBox*)m_TextList.GetAt(i);
556         for (int j = 0; j < pOther->m_TextList.GetSize(); j ++) {
557             CTextBox* pOtherText = (CTextBox*)pOther->m_TextList.GetAt(j);
558             FX_FLOAT inter_left, inter_right;
559             if (!GetIntersection(pText->m_Left, pText->m_Right,
560                                  pOtherText->m_Left, pOtherText->m_Right, inter_left, inter_right)) {
561                 continue;
562             }
563             FX_FLOAT inter_w = inter_right - inter_left;
564             if (inter_w < pText->m_SpaceWidth / 2 && inter_w < pOtherText->m_SpaceWidth / 2) {
565                 continue;
566             }
567             if (dy >= (pText->m_Bottom - pText->m_Top) / 2 ||
568                     dy >= (pOtherText->m_Bottom - pOtherText->m_Top) / 2) {
569                 return FALSE;
570             }
571         }
572     }
573     return TRUE;
574 }
575 void CTextBaseLine::Merge(CTextBaseLine* pOther)
576 {
577     for (int i = 0; i < pOther->m_TextList.GetSize(); i ++) {
578         CTextBox* pText = (CTextBox*)pOther->m_TextList.GetAt(i);
579         InsertTextBox(pText->m_Left, pText->m_Right, pText->m_Top, pText->m_Bottom,
580                       pText->m_SpaceWidth, pText->m_FontSizeV, pText->m_Text);
581     }
582 }
583 FX_BOOL CTextBaseLine::GetWidth(FX_FLOAT& leftx, FX_FLOAT& rightx)
584 {
585     int i;
586     for (i = 0; i < m_TextList.GetSize(); i ++) {
587         CTextBox* pText = (CTextBox*)m_TextList.GetAt(i);
588         if (pText->m_Text != L" ") {
589             break;
590         }
591     }
592     if (i == m_TextList.GetSize()) {
593         return FALSE;
594     }
595     CTextBox* pText = (CTextBox*)m_TextList.GetAt(i);
596     leftx = pText->m_Left;
597     for (i = m_TextList.GetSize() - 1; i >= 0; i --) {
598         CTextBox* pText = (CTextBox*)m_TextList.GetAt(i);
599         if (pText->m_Text != L" ") {
600             break;
601         }
602     }
603     pText = (CTextBox*)m_TextList.GetAt(i);
604     rightx = pText->m_Right;
605     return TRUE;
606 }
607 void CTextBaseLine::MergeBoxes()
608 {
609     int i = 0;
610     while (1) {
611         if (i >= m_TextList.GetSize() - 1) {
612             break;
613         }
614         CTextBox* pThisText = (CTextBox*)m_TextList.GetAt(i);
615         CTextBox* pNextText = (CTextBox*)m_TextList.GetAt(i + 1);
616         FX_FLOAT dx = pNextText->m_Left - pThisText->m_Right;
617         FX_FLOAT spacew = (pThisText->m_SpaceWidth == 0.0) ?
618                           pNextText->m_SpaceWidth : pThisText->m_SpaceWidth;
619         if (spacew > 0.0 && dx < spacew * 2) {
620             pThisText->m_Right = pNextText->m_Right;
621             if (dx > spacew * 1.5) {
622                 pThisText->m_Text += L"  ";
623             } else if (dx > spacew / 3) {
624                 pThisText->m_Text += L' ';
625             }
626             pThisText->m_Text += pNextText->m_Text;
627             pThisText->m_SpaceWidth = pNextText->m_SpaceWidth == 0.0 ?
628                                       spacew : pNextText->m_SpaceWidth;
629             m_TextList.RemoveAt(i + 1);
630             delete pNextText;
631         } else {
632             i ++;
633         }
634     }
635 }
636 void CTextBaseLine::WriteOutput(CFX_WideString& str, FX_FLOAT leftx, FX_FLOAT pagewidth,
637                                 int iTextWidth)
638 {
639     int lastpos = -1;
640     for (int i = 0; i < m_TextList.GetSize(); i ++) {
641         CTextBox* pText = (CTextBox*)m_TextList.GetAt(i);
642         int xpos;
643         if (pText->m_pColumn) {
644             xpos = (int)((pText->m_pColumn->m_AvgPos - leftx) * iTextWidth / pagewidth + 0.5);
645             xpos -= pText->m_Text.GetLength();
646         } else {
647             xpos = (int)((pText->m_Left - leftx) * iTextWidth / pagewidth + 0.5);
648         }
649         if (xpos <= lastpos) {
650             xpos = lastpos + 1;
651         }
652         for (int j = lastpos + 1; j < xpos; j ++) {
653             str += ' ';
654         }
655         CFX_WideString sSrc(pText->m_Text);
656         NormalizeString(sSrc);
657         str += sSrc;
658         str += ' ';
659         lastpos = xpos + pText->m_Text.GetLength();
660     }
661 }
662 void CTextBaseLine::CountChars(int& count, FX_FLOAT& width, int& minchars)
663 {
664     minchars = 0;
665     for (int i = 0; i < m_TextList.GetSize(); i ++) {
666         CTextBox* pText = (CTextBox*)m_TextList.GetAt(i);
667         if (pText->m_Right - pText->m_Left < 0.002) {
668             continue;
669         }
670         count += pText->m_Text.GetLength();
671         width += pText->m_Right - pText->m_Left;
672         minchars += pText->m_Text.GetLength() + 1;
673     }
674 }
675 #define PI 3.1415926535897932384626433832795
676 static void CheckRotate(CPDF_Page& page, CFX_FloatRect& page_bbox)
677 {
678     int total_count = 0, rotated_count[3] = {0, 0, 0};
679     FX_POSITION pos = page.GetFirstObjectPosition();
680     while (pos) {
681         CPDF_PageObject* pObj = page.GetNextObject(pos);
682         if (pObj->m_Type != PDFPAGE_TEXT) {
683             continue;
684         }
685         total_count ++;
686         CPDF_TextObject* pText = (CPDF_TextObject*)pObj;
687         FX_FLOAT angle = pText->m_TextState.GetBaselineAngle();
688         if (angle == 0.0) {
689             continue;
690         }
691         int degree = (int)(angle * 180 / PI + 0.5);
692         if (degree % 90) {
693             continue;
694         }
695         if (degree < 0) {
696             degree += 360;
697         }
698         int index = degree / 90 % 3 - 1;
699         if (index < 0) {
700             continue;
701         }
702         rotated_count[index] ++;
703     }
704     if (total_count == 0) {
705         return;
706     }
707     CFX_AffineMatrix matrix;
708     if (rotated_count[0] > total_count * 2 / 3) {
709         matrix.Set(0, -1, 1, 0, 0, page.GetPageHeight());
710     } else if (rotated_count[1] > total_count * 2 / 3) {
711         matrix.Set(-1, 0, 0, -1, page.GetPageWidth(), page.GetPageHeight());
712     } else if (rotated_count[2] > total_count * 2 / 3) {
713         matrix.Set(0, 1, -1, 0, page.GetPageWidth(), 0);
714     } else {
715         return;
716     }
717     page.Transform(matrix);
718     page_bbox.Transform(&matrix);
719 }
720 void PDF_GetPageText_Unicode(CFX_WideStringArray& lines, CPDF_Document* pDoc, CPDF_Dictionary* pPage,
721                              int iMinWidth, FX_DWORD flags)
722 {
723     lines.RemoveAll();
724     if (pPage == NULL) {
725         return;
726     }
727     CPDF_Page page;
728     page.Load(pDoc, pPage);
729     CPDF_ParseOptions options;
730     options.m_bTextOnly = TRUE;
731     options.m_bSeparateForm = FALSE;
732     page.ParseContent(&options);
733     CFX_FloatRect page_bbox = page.GetPageBBox();
734     if (flags & PDF2TXT_AUTO_ROTATE) {
735         CheckRotate(page, page_bbox);
736     }
737     CTextPage texts;
738     texts.m_bAutoWidth = flags & PDF2TXT_AUTO_WIDTH;
739     texts.m_bKeepColumn = flags & PDF2TXT_KEEP_COLUMN;
740     texts.m_bBreakSpace = TRUE;
741     FX_POSITION pos = page.GetFirstObjectPosition();
742     while (pos) {
743         CPDF_PageObject* pObject = page.GetNextObject(pos);
744         if (!(flags & PDF2TXT_INCLUDE_INVISIBLE)) {
745             CFX_FloatRect rect(pObject->m_Left, pObject->m_Bottom, pObject->m_Right, pObject->m_Top);
746             if (!page_bbox.Contains(rect)) {
747                 continue;
748             }
749         }
750         texts.ProcessObject(pObject);
751     }
752     texts.WriteOutput(lines, iMinWidth);
753 }
754 void PDF_GetPageText(CFX_ByteStringArray& lines, CPDF_Document* pDoc, CPDF_Dictionary* pPage,
755                      int iMinWidth, FX_DWORD flags)
756 {
757     lines.RemoveAll();
758     CFX_WideStringArray wlines;
759     PDF_GetPageText_Unicode(wlines, pDoc, pPage, iMinWidth, flags);
760     for (int i = 0; i < wlines.GetSize(); i ++) {
761         CFX_WideString wstr = wlines[i];
762         CFX_ByteString str;
763         for (int c = 0; c < wstr.GetLength(); c ++) {
764             str += CharFromUnicodeAlt(wstr[c], FXSYS_GetACP(), "?");
765         }
766         lines.Add(str);
767     }
768 }
769 extern void _PDF_GetTextStream_Unicode(CFX_WideTextBuf& buffer, CPDF_PageObjects* pPage, FX_BOOL bUseLF,
770                                        CFX_PtrArray* pObjArray);
771 void PDF_GetTextStream_Unicode(CFX_WideTextBuf& buffer, CPDF_Document* pDoc, CPDF_Dictionary* pPage, FX_DWORD flags)
772 {
773     buffer.EstimateSize(0, 10240);
774     CPDF_Page page;
775     page.Load(pDoc, pPage);
776     CPDF_ParseOptions options;
777     options.m_bTextOnly = TRUE;
778     options.m_bSeparateForm = FALSE;
779     page.ParseContent(&options);
780     _PDF_GetTextStream_Unicode(buffer, &page, TRUE, NULL);
781 }