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