Merge to XFA: Remove CFX_AffineMatrix/CPDF_Matrix

core/src/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 <cctype>
 #include <cwctype>
 #include <algorithm>
 
@@ skipping 33 matching lines @@
   if (threshold < 500) {
     return threshold / 4.0f;
   }
   if (threshold < 700) {
     return threshold / 5.0f;
   }
   return threshold / 6.0f;
 }
 
 FX_FLOAT _CalculateBaseSpace(const CPDF_TextObject* pTextObj,
-                             const CFX_AffineMatrix& matrix) {
+                             const CFX_Matrix& matrix) {
   FX_FLOAT baseSpace = 0.0;
   const int nItems = pTextObj->CountItems();
   if (pTextObj->m_TextState.GetObject()->m_CharSpace && nItems >= 3) {
     FX_BOOL bAllChar = TRUE;
     FX_FLOAT spacing = matrix.TransformDistance(
         pTextObj->m_TextState.GetObject()->m_CharSpace);
     baseSpace = spacing;
     for (int i = 0; i < nItems; i++) {
       CPDF_TextObjectItem item;
       pTextObj->GetItemInfo(i, &item);
@@ skipping 193 matching lines @@
     if (!pCurObj) {
       pCurObj = info_curchar.m_pTextObj;
     }
     if (pCurObj != info_curchar.m_pTextObj) {
       rectArray.Add(rect);
       pCurObj = info_curchar.m_pTextObj;
       flagNewRect = TRUE;
     }
     if (flagNewRect) {
       FX_FLOAT orgX = info_curchar.m_OriginX, orgY = info_curchar.m_OriginY;
-      CFX_AffineMatrix matrix, matrix_reverse;
+      CFX_Matrix matrix, matrix_reverse;
       info_curchar.m_pTextObj->GetTextMatrix(&matrix);
       matrix.Concat(info_curchar.m_Matrix);
       matrix_reverse.SetReverse(matrix);
       matrix_reverse.Transform(orgX, orgY);
       rect.left = info_curchar.m_CharBox.left;
       rect.right = info_curchar.m_CharBox.right;
       if (pCurObj->GetFont()->GetTypeDescent()) {
         rect.bottom = orgY +
                       pCurObj->GetFont()->GetTypeDescent() *
                           pCurObj->GetFontSize() / 1000;
@@ skipping 622 matching lines @@
   pos = m_pPage->GetFirstObjectPosition();
   if (!pos) {
     return;
   }
   m_TextlineDir = FindTextlineFlowDirection();
   int nCount = 0;
   while (pos) {
     pPageObj = m_pPage->GetNextObject(pos);
     if (pPageObj) {
       if (pPageObj->m_Type == PDFPAGE_TEXT) {
-        CFX_AffineMatrix matrix;
+        CFX_Matrix matrix;
         ProcessTextObject((CPDF_TextObject*)pPageObj, matrix, pos);
         nCount++;
       } else if (pPageObj->m_Type == PDFPAGE_FORM) {
-        CFX_AffineMatrix formMatrix(1, 0, 0, 1, 0, 0);
+        CFX_Matrix formMatrix(1, 0, 0, 1, 0, 0);
         ProcessFormObject((CPDF_FormObject*)pPageObj, formMatrix);
       }
     }
     pPageObj = NULL;
   }
   int count = m_LineObj.GetSize();
   for (int i = 0; i < count; i++) {
     ProcessTextObject(m_LineObj.GetAt(i));
   }
   m_LineObj.RemoveAll();
   CloseTempLine();
 }
 void CPDF_TextPage::ProcessFormObject(CPDF_FormObject* pFormObj,
-                                      const CFX_AffineMatrix& formMatrix) {
+                                      const CFX_Matrix& formMatrix) {
   CPDF_PageObject* pPageObj = NULL;
   FX_POSITION pos;
   if (!pFormObj) {
     return;
   }
   pos = pFormObj->m_pForm->GetFirstObjectPosition();
   if (!pos) {
     return;
   }
-  CFX_AffineMatrix curFormMatrix;
+  CFX_Matrix curFormMatrix;
   curFormMatrix.Copy(pFormObj->m_FormMatrix);
   curFormMatrix.Concat(formMatrix);
   while (pos) {
     pPageObj = pFormObj->m_pForm->GetNextObject(pos);
     if (pPageObj) {
       if (pPageObj->m_Type == PDFPAGE_TEXT) {
         ProcessTextObject((CPDF_TextObject*)pPageObj, curFormMatrix, pos);
       } else if (pPageObj->m_Type == PDFPAGE_FORM) {
         ProcessFormObject((CPDF_FormObject*)pPageObj, curFormMatrix);
       }
@@ skipping 230 matching lines @@
           AddCharInfoByLRDirection(str, n);
         }
       }
     }
   }
   order.RemoveAll();
   m_TempCharList.RemoveAll();
   m_TempTextBuf.Delete(0, m_TempTextBuf.GetLength());
 }
 void CPDF_TextPage::ProcessTextObject(CPDF_TextObject* pTextObj,
-                                      const CFX_AffineMatrix& formMatrix,
+                                      const CFX_Matrix& formMatrix,
                                       FX_POSITION ObjPos) {
   CFX_FloatRect re(pTextObj->m_Left, pTextObj->m_Bottom, pTextObj->m_Right,
                    pTextObj->m_Top);
   if (FXSYS_fabs(pTextObj->m_Right - pTextObj->m_Left) < 0.01f) {
     return;
   }
   int count = m_LineObj.GetSize();
   PDFTEXT_Obj Obj;
   Obj.m_pTextObj = pTextObj;
   Obj.m_formMatrix = formMatrix;
   if (count == 0) {
     m_LineObj.Add(Obj);
     return;
   }
   if (IsSameAsPreTextObject(pTextObj, ObjPos)) {
     return;
   }
   PDFTEXT_Obj prev_Obj = m_LineObj.GetAt(count - 1);
   CPDF_TextObjectItem item;
   int nItem = prev_Obj.m_pTextObj->CountItems();
   prev_Obj.m_pTextObj->GetItemInfo(nItem - 1, &item);
   FX_FLOAT prev_width =
       GetCharWidth(item.m_CharCode, prev_Obj.m_pTextObj->GetFont()) *
       prev_Obj.m_pTextObj->GetFontSize() / 1000;
-  CFX_AffineMatrix prev_matrix;
+  CFX_Matrix prev_matrix;
   prev_Obj.m_pTextObj->GetTextMatrix(&prev_matrix);
   prev_width = FXSYS_fabs(prev_width);
   prev_matrix.Concat(prev_Obj.m_formMatrix);
   prev_width = prev_matrix.TransformDistance(prev_width);
   pTextObj->GetItemInfo(0, &item);
   FX_FLOAT this_width = GetCharWidth(item.m_CharCode, pTextObj->GetFont()) *
                         pTextObj->GetFontSize() / 1000;
   this_width = FXSYS_fabs(this_width);
-  CFX_AffineMatrix this_matrix;
+  CFX_Matrix this_matrix;
   pTextObj->GetTextMatrix(&this_matrix);
   this_width = FXSYS_fabs(this_width);
   this_matrix.Concat(formMatrix);
   this_width = this_matrix.TransformDistance(this_width);
   FX_FLOAT threshold =
       prev_width > this_width ? prev_width / 4 : this_width / 4;
   FX_FLOAT prev_x = prev_Obj.m_pTextObj->GetPosX(),
            prev_y = prev_Obj.m_pTextObj->GetPosY();
   prev_Obj.m_formMatrix.Transform(prev_x, prev_y);
   m_DisplayMatrix.Transform(prev_x, prev_y);
   FX_FLOAT this_x = pTextObj->GetPosX(), this_y = pTextObj->GetPosY();
   formMatrix.Transform(this_x, this_y);
   m_DisplayMatrix.Transform(this_x, this_y);
   if (FXSYS_fabs(this_y - prev_y) > threshold * 2) {
     for (int i = 0; i < count; i++) {
       ProcessTextObject(m_LineObj.GetAt(i));
     }
     m_LineObj.RemoveAll();
     m_LineObj.Add(Obj);
     return;
   }
   int i = 0;
   if (m_ParseOptions.m_bNormalizeObjs) {
     for (i = count - 1; i >= 0; i--) {
       PDFTEXT_Obj prev_Obj = m_LineObj.GetAt(i);
-      CFX_AffineMatrix prev_matrix;
+      CFX_Matrix prev_matrix;
       prev_Obj.m_pTextObj->GetTextMatrix(&prev_matrix);
       FX_FLOAT Prev_x = prev_Obj.m_pTextObj->GetPosX(),
                Prev_y = prev_Obj.m_pTextObj->GetPosY();
       prev_Obj.m_formMatrix.Transform(Prev_x, Prev_y);
       m_DisplayMatrix.Transform(Prev_x, Prev_y);
       if (this_x >= Prev_x) {
         if (i == count - 1) {
           m_LineObj.Add(Obj);
         } else {
           m_LineObj.InsertAt(i + 1, Obj);
@@ skipping 101 matching lines @@
         ToString(pDict ? pDict->GetElement(FX_BSTRC("ActualText")) : nullptr);
     if (temp) {
       actText = temp->GetUnicodeText();
     }
   }
   FX_STRSIZE nItems = actText.GetLength();
   if (nItems < 1) {
     return;
   }
   CPDF_Font* pFont = pTextObj->GetFont();
-  CFX_AffineMatrix formMatrix = Obj.m_formMatrix;
-  CFX_AffineMatrix matrix;
+  CFX_Matrix formMatrix = Obj.m_formMatrix;
+  CFX_Matrix matrix;
   pTextObj->GetTextMatrix(&matrix);
   matrix.Concat(formMatrix);
   FX_FLOAT fPosX = pTextObj->GetPosX();
   FX_FLOAT fPosY = pTextObj->GetPosY();
   int nCharInfoIndex = m_TextBuf.GetLength();
   CFX_FloatRect charBox;
   charBox.top = pTextObj->m_Top;
   charBox.left = pTextObj->m_Left;
   charBox.right = pTextObj->m_Right;
   charBox.bottom = pTextObj->m_Bottom;
@@ skipping 91 matching lines @@
       nL2R++;
     }
   }
   return (nR2L > 0 && nR2L >= nL2R);
 }
 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_AffineMatrix formMatrix = Obj.m_formMatrix;
+  CFX_Matrix formMatrix = Obj.m_formMatrix;
   CPDF_Font* pFont = pTextObj->GetFont();
-  CFX_AffineMatrix matrix;
+  CFX_Matrix matrix;
   pTextObj->GetTextMatrix(&matrix);
   matrix.Concat(formMatrix);
   int32_t bPreMKC = PreMarkedContent(Obj);
   if (FPDFTEXT_MC_DONE == bPreMKC) {
     m_pPreTextObj = pTextObj;
     m_perMatrix.Copy(formMatrix);
     return;
   }
   int result = 0;
   if (m_pPreTextObj) {
@@ skipping 309 matching lines @@
       preChar = (PAGECHAR_INFO)m_charList[size - 1];
     }
     if (FPDFTEXT_CHAR_PIECE == preChar.m_Flag)
       if (0xAD == preChar.m_Unicode || 0x2D == preChar.m_Unicode) {
         return TRUE;
       }
   }
   return FALSE;
 }
 int CPDF_TextPage::ProcessInsertObject(const CPDF_TextObject* pObj,
-                                       const CFX_AffineMatrix& formMatrix) {
+                                       const CFX_Matrix& formMatrix) {
   FindPreviousTextObject();
   FX_BOOL bNewline = FALSE;
   int WritingMode = GetTextObjectWritingMode(pObj);
   if (WritingMode == -1) {
     WritingMode = GetTextObjectWritingMode(m_pPreTextObj);
   }
   CFX_FloatRect this_rect(pObj->m_Left, pObj->m_Bottom, pObj->m_Right,
                           pObj->m_Top);
   CFX_FloatRect prev_rect(m_pPreTextObj->m_Left, m_pPreTextObj->m_Bottom,
                           m_pPreTextObj->m_Right, m_pPreTextObj->m_Top);
@@ skipping 38 matching lines @@
   }
   FX_FLOAT last_pos = PrevItem.m_OriginX;
   int nLastWidth = GetCharWidth(PrevItem.m_CharCode, m_pPreTextObj->GetFont());
   FX_FLOAT last_width = nLastWidth * m_pPreTextObj->GetFontSize() / 1000;
   last_width = FXSYS_fabs(last_width);
   int nThisWidth = GetCharWidth(item.m_CharCode, pObj->GetFont());
   FX_FLOAT this_width = nThisWidth * pObj->GetFontSize() / 1000;
   this_width = FXSYS_fabs(this_width);
   FX_FLOAT threshold =
       last_width > this_width ? last_width / 4 : this_width / 4;
-  CFX_AffineMatrix prev_matrix, prev_reverse;
+  CFX_Matrix prev_matrix, prev_reverse;
   m_pPreTextObj->GetTextMatrix(&prev_matrix);
   prev_matrix.Concat(m_perMatrix);
   prev_reverse.SetReverse(prev_matrix);
   FX_FLOAT x = pObj->GetPosX();
   FX_FLOAT y = pObj->GetPosY();
   formMatrix.Transform(x, y);
   prev_reverse.Transform(x, y);
   if (last_width < this_width) {
     threshold = prev_reverse.TransformDistance(threshold);
   }
   CFX_FloatRect rect1(m_pPreTextObj->m_Left, pObj->m_Bottom,
                       m_pPreTextObj->m_Right, pObj->m_Top);
   CFX_FloatRect rect2(m_pPreTextObj->m_Left, m_pPreTextObj->m_Bottom,
                       m_pPreTextObj->m_Right, m_pPreTextObj->m_Top);
   CFX_FloatRect rect3 = rect1;
   rect1.Intersect(rect2);
   if (WritingMode == 0) {
     if ((rect1.IsEmpty() && rect2.Height() > 5 && rect3.Height() > 5) ||
         ((y > threshold * 2 || y < threshold * -3) &&
          (FXSYS_fabs(y) < 1 ? FXSYS_fabs(x) < FXSYS_fabs(y) : TRUE))) {
       bNewline = TRUE;
       if (nItem > 1) {
         CPDF_TextObjectItem tempItem;
         m_pPreTextObj->GetItemInfo(0, &tempItem);
-        CFX_AffineMatrix m;
+        CFX_Matrix m;
         m_pPreTextObj->GetTextMatrix(&m);
         if (PrevItem.m_OriginX > tempItem.m_OriginX &&
             m_DisplayMatrix.a > 0.9 && m_DisplayMatrix.b < 0.1 &&
             m_DisplayMatrix.c < 0.1 && m_DisplayMatrix.d < -0.9 && m.b < 0.1 &&
             m.c < 0.1) {
           CFX_FloatRect re(0, m_pPreTextObj->m_Bottom, 1000,
                            m_pPreTextObj->m_Top);
           if (re.Contains(pObj->GetPosX(), pObj->GetPosY())) {
             bNewline = FALSE;
           } else {
@@ skipping 14 matching lines @@
     return 2;
   }
   int32_t nChars = pObj->CountChars();
   if (nChars == 1 && (0x2D == curChar || 0xAD == curChar))
     if (IsHyphen(curChar)) {
       return 3;
     }
   CFX_WideString PrevStr =
       m_pPreTextObj->GetFont()->UnicodeFromCharCode(PrevItem.m_CharCode);
   FX_WCHAR preChar = PrevStr.GetAt(PrevStr.GetLength() - 1);
-  CFX_AffineMatrix matrix;
+  CFX_Matrix matrix;
   pObj->GetTextMatrix(&matrix);
   matrix.Concat(formMatrix);
   threshold = (FX_FLOAT)(nLastWidth > nThisWidth ? nLastWidth : nThisWidth);
   threshold = threshold > 400
                   ? (threshold < 700
                          ? threshold / 4
                          : (threshold > 800 ? threshold / 6 : threshold / 5))
                   : (threshold / 2);
   if (nLastWidth >= nThisWidth) {
     threshold *= FXSYS_fabs(m_pPreTextObj->GetFontSize());
@@ skipping 779 matching lines @@
   if (!m_bIsParsed || index < 0 || index >= m_LinkList.GetSize()) {
     return;
   }
   CPDF_LinkExt* link = NULL;
   link = m_LinkList.GetAt(index);
   if (!link) {
     return;
   }
   m_pTextPage->GetRectArray(link->m_Start, link->m_Count, rects);
 }