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