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