More define cleanup.

core/fpdftext/fpdf_text_int.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #include <algorithm>
 #include <cctype>
 #include <cwctype>
 #include <memory>
@@ skipping 10 matching lines @@
 #include "core/fpdfapi/fpdf_parser/include/cpdf_string.h"
 #include "core/fpdftext/include/cpdf_linkextract.h"
 #include "core/fpdftext/include/cpdf_textpage.h"
 #include "core/fpdftext/include/cpdf_textpagefind.h"
 #include "core/fpdftext/unicodenormalizationdata.h"
 #include "core/fxcrt/fx_bidi.h"
 #include "core/fxcrt/include/fx_ext.h"
 #include "core/fxcrt/include/fx_ucd.h"
 #include "third_party/base/stl_util.h"
 
-#define FPDFTEXT_RLTB 1
-#define FPDFTEXT_LEFT -1
-#define FPDFTEXT_RIGHT 1
-
 #define FPDFTEXT_MATCHCASE 0x00000001
 #define FPDFTEXT_MATCHWHOLEWORD 0x00000002
 #define FPDFTEXT_CONSECUTIVE 0x00000004
 
 #define FPDFTEXT_CHAR_ERROR -1
 #define FPDFTEXT_CHAR_NORMAL 0
 #define FPDFTEXT_CHAR_GENERATED 1
 #define FPDFTEXT_CHAR_UNUNICODE 2
 #define FPDFTEXT_CHAR_HYPHEN 3
 #define FPDFTEXT_CHAR_PIECE 4
-#define FPDFTEXT_MC_PASS 0
-#define FPDFTEXT_MC_DONE 1
-#define FPDFTEXT_MC_DELAY 2
+
+#define TEXT_BLANK_CHAR L' '
+#define TEXT_LINEFEED_CHAR L'\n'
+#define TEXT_RETURN_CHAR L'\r'
+#define TEXT_EMPTY L""
+#define TEXT_BLANK L" "
+#define TEXT_RETURN_LINEFEED L"\r\n"
+#define TEXT_LINEFEED L"\n"
+#define TEXT_CHARRATIO_GAPDELTA 0.070
 
 namespace {
 
 const FX_FLOAT kDefaultFontSize = 1.0f;
 const uint16_t* const g_UnicodeData_Normalization_Maps[5] = {
     nullptr, g_UnicodeData_Normalization_Map1, g_UnicodeData_Normalization_Map2,
     g_UnicodeData_Normalization_Map3, g_UnicodeData_Normalization_Map4};
 
 FX_BOOL IsIgnoreSpaceCharacter(FX_WCHAR curChar) {
   if (curChar < 255) {
@@ skipping 78 matching lines @@
     FX_WCHAR n = wFind;
     while (n--) {
       *pDst++ = *pMap++;
     }
   }
   return (FX_STRSIZE)wFind;
 }
 
 }  // namespace
 
-#define TEXT_BLANK_CHAR L' '
-#define TEXT_LINEFEED_CHAR L'\n'
-#define TEXT_RETURN_CHAR L'\r'
-#define TEXT_EMPTY L""
-#define TEXT_BLANK L" "
-#define TEXT_RETURN_LINEFEED L"\r\n"
-#define TEXT_LINEFEED L"\n"
-#define TEXT_CHARRATIO_GAPDELTA 0.070
-
-CPDF_TextPage::CPDF_TextPage(const CPDF_Page* pPage, int flags)
+CPDF_TextPage::CPDF_TextPage(const CPDF_Page* pPage, FPDFText_Direction flags)
     : m_pPage(pPage),
       m_parserflag(flags),
       m_pPreTextObj(nullptr),
       m_bIsParsed(false),
       m_TextlineDir(-1),
       m_CurlineRect(0, 0, 0, 0) {
   m_TextBuf.EstimateSize(0, 10240);
   pPage->GetDisplayMatrix(m_DisplayMatrix, 0, 0, (int)pPage->GetPageWidth(),
                           (int)pPage->GetPageHeight(), 0);
 }
@@ skipping 440 matching lines @@
 
   if (rectIndex < 0 || rectIndex >= pdfium::CollectionSize<int>(m_SelRects))
     return;
 
   left = m_SelRects[rectIndex].left;
   top = m_SelRects[rectIndex].top;
   right = m_SelRects[rectIndex].right;
   bottom = m_SelRects[rectIndex].bottom;
 }
 
-FX_BOOL CPDF_TextPage::GetBaselineRotate(int start, int end, int& Rotate) {
-  if (end == start) {
-    return FALSE;
-  }
-  FPDF_CHAR_INFO info_start;
-  FPDF_CHAR_INFO info_end;
-  GetCharInfo(start, &info_start);
-  GetCharInfo(end, &info_end);
-  while (info_end.m_CharBox.Width() == 0 || info_end.m_CharBox.Height() == 0) {
-    if (--end <= start)
-      return FALSE;
-
-    GetCharInfo(end, &info_end);
-  }
-  FX_FLOAT dx = (info_end.m_OriginX - info_start.m_OriginX);
-  FX_FLOAT dy = (info_end.m_OriginY - info_start.m_OriginY);
-  if (dx == 0) {
-    if (dy > 0) {
-      Rotate = 90;
-    } else if (dy < 0) {
-      Rotate = 270;
-    } else {
-      Rotate = 0;
-    }
-  } else {
-    float a = FXSYS_atan2(dy, dx);
-    Rotate = (int)(a * 180 / FX_PI + 0.5);
-  }
-  if (Rotate < 0) {
-    Rotate = -Rotate;
-  } else if (Rotate > 0) {
-    Rotate = 360 - Rotate;
-  }
-  return TRUE;
-}
-
 int CPDF_TextPage::CountBoundedSegments(FX_FLOAT left,
                                         FX_FLOAT top,
                                         FX_FLOAT right,
                                         FX_FLOAT bottom,
                                         FX_BOOL bContains) {
   m_Segments.RemoveAll();
   if (!m_bIsParsed)
     return -1;
 
   CFX_FloatRect rect(left, bottom, right, top);
@@ skipping 58 matching lines @@
   }
   if (segmentStatus == 1) {
     segmentStatus = 2;
     m_Segments.Add(segment);
     segment.m_Start = 0;
     segment.m_nCount = 0;
   }
   return m_Segments.GetSize();
 }
 
-int CPDF_TextPage::GetWordBreak(int index, int direction) const {
-  if (!m_bIsParsed)
-    return -1;
-
-  if (direction != FPDFTEXT_LEFT && direction != FPDFTEXT_RIGHT)
-    return -1;
-
-  if (index < 0 || index >= pdfium::CollectionSize<int>(m_CharList))
-    return -1;
-
-  const PAGECHAR_INFO& charinfo = m_CharList[index];
-  if (charinfo.m_Index == -1 || charinfo.m_Flag == FPDFTEXT_CHAR_GENERATED) {
-    return index;
-  }
-  if (!IsLetter(charinfo.m_Unicode)) {
-    return index;
-  }
-  int breakPos = index;
-  if (direction == FPDFTEXT_LEFT) {
-    while (--breakPos > 0) {
-      if (!IsLetter(m_CharList[breakPos].m_Unicode))
-        break;
-    }
-  } else if (direction == FPDFTEXT_RIGHT) {
-    while (++breakPos < pdfium::CollectionSize<int>(m_CharList)) {
-      if (!IsLetter(m_CharList[breakPos].m_Unicode))
-        break;
-    }
-  }
-  return breakPos;
-}
-
 int32_t CPDF_TextPage::FindTextlineFlowDirection() {
   const int32_t nPageWidth = static_cast<int32_t>(m_pPage->GetPageWidth());
   const int32_t nPageHeight = static_cast<int32_t>(m_pPage->GetPageHeight());
   std::vector<uint8_t> nHorizontalMask(nPageWidth);
   std::vector<uint8_t> nVerticalMask(nPageHeight);
   uint8_t* pDataH = nHorizontalMask.data();
   uint8_t* pDataV = nVerticalMask.data();
   int32_t index = 0;
   FX_FLOAT fLineHeight = 0.0f;
   if (m_pPage->GetPageObjectList()->empty())
@@ skipping 126 matching lines @@
     return w;
 
   CFX_ByteString str;
   pFont->AppendChar(str, charCode);
   if (int w = pFont->GetStringWidth(str.c_str(), 1))
     return w;
 
   return pFont->GetCharBBox(charCode).Width();
 }
 
-void CPDF_TextPage::OnPiece(CFX_BidiChar* pBidi, CFX_WideString& str) {
-  CFX_BidiChar::Segment seg = pBidi->GetSegmentInfo();
-  if (seg.direction == CFX_BidiChar::RIGHT) {
-    for (int i = seg.start + seg.count; i > seg.start; i--) {
-      m_TextBuf.AppendChar(str.GetAt(i - 1));
-      m_CharList.push_back(m_TempCharList[i - 1]);
-    }
-  } else {
-    for (int i = seg.start; i < seg.start + seg.count; i++) {
-      m_TextBuf.AppendChar(str.GetAt(i));
-      m_CharList.push_back(m_TempCharList[i]);
-    }
-  }
-}
-
 void CPDF_TextPage::AddCharInfoByLRDirection(FX_WCHAR wChar,
                                              PAGECHAR_INFO info) {
   if (!IsControlChar(info)) {
     info.m_Index = m_TextBuf.GetLength();
     if (wChar >= 0xFB00 && wChar <= 0xFB06) {
       FX_WCHAR* pDst = NULL;
       FX_STRSIZE nCount = Unicode_GetNormalization(wChar, pDst);
       if (nCount >= 1) {
         pDst = FX_Alloc(FX_WCHAR, nCount);
         Unicode_GetNormalization(wChar, pDst);
@@ skipping 56 matching lines @@
     }
     if (bPrevSpace) {
       m_TempTextBuf.Delete(i, 1);
       m_TempCharList.erase(m_TempCharList.begin() + i);
       str.Delete(i);
       i--;
     }
     bPrevSpace = TRUE;
   }
   CFX_BidiString bidi(str);
-  if (m_parserflag == FPDFTEXT_RLTB)
+  if (m_parserflag == FPDFText_Direction::Right)
     bidi.SetOverallDirectionRight();
   CFX_BidiChar::Direction eCurrentDirection = bidi.OverallDirection();
   for (const auto& segment : bidi) {
     if (segment.direction == CFX_BidiChar::RIGHT ||
         (segment.direction == CFX_BidiChar::NEUTRAL &&
          eCurrentDirection == CFX_BidiChar::RIGHT)) {
       eCurrentDirection = CFX_BidiChar::RIGHT;
       for (int m = segment.start + segment.count; m > segment.start; --m)
         AddCharInfoByRLDirection(bidi.CharAt(m - 1), m_TempCharList[m - 1]);
     } else {
@@ skipping 81 matching lines @@
         m_LineObj.InsertAt(i + 1, Obj);
       }
       break;
     }
   }
   if (i < 0) {
     m_LineObj.InsertAt(0, Obj);
   }
 }
 
-int32_t CPDF_TextPage::PreMarkedContent(PDFTEXT_Obj Obj) {
+FPDFText_MarkedContent CPDF_TextPage::PreMarkedContent(PDFTEXT_Obj Obj) {
   CPDF_TextObject* pTextObj = Obj.m_pTextObj;
   CPDF_ContentMarkData* pMarkData =
       (CPDF_ContentMarkData*)pTextObj->m_ContentMark.GetObject();
   if (!pMarkData)
-    return FPDFTEXT_MC_PASS;
+    return FPDFText_MarkedContent::Pass;
 
   int nContentMark = pMarkData->CountItems();
   if (nContentMark < 1)
-    return FPDFTEXT_MC_PASS;
+    return FPDFText_MarkedContent::Pass;
+
   CFX_WideString actText;
   FX_BOOL bExist = FALSE;
   CPDF_Dictionary* pDict = NULL;
   int n = 0;
   for (n = 0; n < nContentMark; n++) {
     CPDF_ContentMarkItem& item = pMarkData->GetItem(n);
     if (item.GetParamType() == CPDF_ContentMarkItem::ParamType::None)
       continue;
     pDict = item.GetParam();
     CPDF_String* temp =
         ToString(pDict ? pDict->GetObjectBy("ActualText") : nullptr);
     if (temp) {
       bExist = TRUE;
       actText = temp->GetUnicodeText();
     }
   }
   if (!bExist)
-    return FPDFTEXT_MC_PASS;
+    return FPDFText_MarkedContent::Pass;
 
   if (m_pPreTextObj) {
     CPDF_ContentMarkData* pPreMarkData =
         (CPDF_ContentMarkData*)m_pPreTextObj->m_ContentMark.GetObject();
     if (pPreMarkData && pPreMarkData->CountItems() == n &&
         pDict == pPreMarkData->GetItem(n - 1).GetParam()) {
-      return FPDFTEXT_MC_DONE;
+      return FPDFText_MarkedContent::Done;
     }
   }
   FX_STRSIZE nItems = actText.GetLength();
   if (nItems < 1)
-    return FPDFTEXT_MC_PASS;
+    return FPDFText_MarkedContent::Pass;
 
   CPDF_Font* pFont = pTextObj->GetFont();
   bExist = FALSE;
   for (FX_STRSIZE i = 0; i < nItems; i++) {
     if (pFont->CharCodeFromUnicode(actText.GetAt(i)) !=
         CPDF_Font::kInvalidCharCode) {
       bExist = TRUE;
       break;
     }
   }
   if (!bExist)
-    return FPDFTEXT_MC_PASS;
+    return FPDFText_MarkedContent::Pass;
 
   bExist = FALSE;
   for (FX_STRSIZE i = 0; i < nItems; i++) {
     FX_WCHAR wChar = actText.GetAt(i);
     if ((wChar > 0x80 && wChar < 0xFFFD) || (wChar <= 0x80 && isprint(wChar))) {
       bExist = TRUE;
       break;
     }
   }
   if (!bExist)
-    return FPDFTEXT_MC_DONE;
+    return FPDFText_MarkedContent::Done;
 
-  return FPDFTEXT_MC_DELAY;
+  return FPDFText_MarkedContent::Delay;
 }
 
 void CPDF_TextPage::ProcessMarkedContent(PDFTEXT_Obj Obj) {
   CPDF_TextObject* pTextObj = Obj.m_pTextObj;
   CPDF_ContentMarkData* pMarkData =
       (CPDF_ContentMarkData*)pTextObj->m_ContentMark.GetObject();
   if (!pMarkData)
     return;
 
   int nContentMark = pMarkData->CountItems();
@@ skipping 102 matching lines @@
 void CPDF_TextPage::ProcessTextObject(PDFTEXT_Obj Obj) {
   CPDF_TextObject* pTextObj = Obj.m_pTextObj;
   if (FXSYS_fabs(pTextObj->m_Right - pTextObj->m_Left) < 0.01f) {
     return;
   }
   CFX_Matrix formMatrix = Obj.m_formMatrix;
   CPDF_Font* pFont = pTextObj->GetFont();
   CFX_Matrix matrix;
   pTextObj->GetTextMatrix(&matrix);
   matrix.Concat(formMatrix);
-  int32_t bPreMKC = PreMarkedContent(Obj);
-  if (FPDFTEXT_MC_DONE == bPreMKC) {
+  FPDFText_MarkedContent ePreMKC = PreMarkedContent(Obj);
+  if (ePreMKC == FPDFText_MarkedContent::Done) {
     m_pPreTextObj = pTextObj;
     m_perMatrix.Copy(formMatrix);
     return;
   }
   int result = 0;
   if (m_pPreTextObj) {
     result = ProcessInsertObject(pTextObj, formMatrix);
     if (2 == result) {
       m_CurlineRect =
           CFX_FloatRect(Obj.m_pTextObj->m_Left, Obj.m_pTextObj->m_Bottom,
@@ skipping 55 matching lines @@
       m_TempTextBuf.Delete(m_TempTextBuf.GetLength() - 1, 1);
       charinfo->m_Unicode = 0x2;
       charinfo->m_Flag = FPDFTEXT_CHAR_HYPHEN;
       m_TempTextBuf.AppendChar(0xfffe);
     }
   } else {
     m_CurlineRect =
         CFX_FloatRect(Obj.m_pTextObj->m_Left, Obj.m_pTextObj->m_Bottom,
                       Obj.m_pTextObj->m_Right, Obj.m_pTextObj->m_Top);
   }
-  if (FPDFTEXT_MC_DELAY == bPreMKC) {
+  if (ePreMKC == FPDFText_MarkedContent::Delay) {
     ProcessMarkedContent(Obj);
     m_pPreTextObj = pTextObj;
     m_perMatrix.Copy(formMatrix);
     return;
   }
   m_pPreTextObj = pTextObj;
   m_perMatrix.Copy(formMatrix);
   int nItems = pTextObj->CountItems();
   FX_FLOAT baseSpace = CalculateBaseSpace(pTextObj, matrix);
 
@@ skipping 496 matching lines @@
   return TRUE;
 }
 
 FX_BOOL CPDF_TextPage::IsRectIntersect(const CFX_FloatRect& rect1,
                                        const CFX_FloatRect& rect2) {
   CFX_FloatRect rect = rect1;
   rect.Intersect(rect2);
   return !rect.IsEmpty();
 }
 
-FX_BOOL CPDF_TextPage::IsLetter(FX_WCHAR unicode) {
-  if (unicode < L'A') {
-    return FALSE;
-  }
-  if (unicode > L'Z' && unicode < L'a') {
-    return FALSE;
-  }
-  if (unicode > L'z') {
-    return FALSE;
-  }
-  return TRUE;
-}
-
 CPDF_TextPageFind::CPDF_TextPageFind(const CPDF_TextPage* pTextPage)
     : m_pTextPage(pTextPage),
       m_flags(0),
       m_findNextStart(-1),
       m_findPreStart(-1),
       m_bMatchCase(FALSE),
       m_bMatchWholeWord(FALSE),
       m_resStart(0),
       m_resEnd(-1),
       m_IsFind(FALSE) {
@@ skipping 537 matching lines @@
   return index < m_LinkArray.size() ? m_LinkArray[index].m_strUrl : L"";
 }
 
 std::vector<CFX_FloatRect> CPDF_LinkExtract::GetRects(size_t index) const {
   if (index >= m_LinkArray.size())
     return std::vector<CFX_FloatRect>();
 
   return m_pTextPage->GetRectArray(m_LinkArray[index].m_Start,
                                    m_LinkArray[index].m_Count);
 }