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