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