Remove CFX_AffineMatrix/CPDF_Matrix

core/src/fpdfapi/fpdf_page/fpdf_page.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 "pageint.h"
 
 #include "core/include/fpdfapi/fpdf_module.h"
 #include "core/include/fpdfapi/fpdf_page.h"
@@ skipping 47 matching lines @@
       ((CPDF_TextObject*)this)->RecalcPositionData();
       break;
     case PDFPAGE_PATH:
       ((CPDF_PathObject*)this)->CalcBoundingBox();
       break;
     case PDFPAGE_SHADING:
       ((CPDF_ShadingObject*)this)->CalcBoundingBox();
       break;
   }
 }
-void CPDF_PageObject::TransformClipPath(CFX_AffineMatrix& matrix) {
+void CPDF_PageObject::TransformClipPath(CFX_Matrix& matrix) {
   if (m_ClipPath.IsNull()) {
     return;
   }
   m_ClipPath.GetModify();
   m_ClipPath.Transform(matrix);
 }
-void CPDF_PageObject::TransformGeneralState(CFX_AffineMatrix& matrix) {
+void CPDF_PageObject::TransformGeneralState(CFX_Matrix& matrix) {
   if (m_GeneralState.IsNull()) {
     return;
   }
   CPDF_GeneralStateData* pGS = m_GeneralState.GetModify();
   pGS->m_Matrix.Concat(matrix);
 }
-FX_RECT CPDF_PageObject::GetBBox(const CFX_AffineMatrix* pMatrix) const {
+FX_RECT CPDF_PageObject::GetBBox(const CFX_Matrix* pMatrix) const {
   CFX_FloatRect rect(m_Left, m_Bottom, m_Right, m_Top);
   if (pMatrix) {
     pMatrix->TransformRect(rect);
   }
   return rect.GetOutterRect();
 }
 
 CPDF_TextObject::CPDF_TextObject()
     : m_PosX(0),
       m_PosY(0),
@@ skipping 109 matching lines @@
     for (int i = 0; i < m_nChars - 1; ++i) {
       m_pCharPos[i] = pSrcObj->m_pCharPos[i];
     }
   } else {
     m_pCharCodes = pSrcObj->m_pCharCodes;
   }
   m_PosX = pSrcObj->m_PosX;
   m_PosY = pSrcObj->m_PosY;
 }
 
-void CPDF_TextObject::GetTextMatrix(CFX_AffineMatrix* pMatrix) const {
+void CPDF_TextObject::GetTextMatrix(CFX_Matrix* pMatrix) const {
   FX_FLOAT* pTextMatrix = m_TextState.GetMatrix();
   pMatrix->Set(pTextMatrix[0], pTextMatrix[2], pTextMatrix[1], pTextMatrix[3],
                m_PosX, m_PosY);
 }
 
 void CPDF_TextObject::SetSegments(const CFX_ByteString* pStrs,
                                   FX_FLOAT* pKerning,
                                   int nsegs) {
   if (m_nChars > 1) {
     FX_Free(m_pCharCodes);
@@ skipping 279 matching lines @@
   } else {
     if (pTextAdvanceX) {
       *pTextAdvanceX = FXSYS_Mul(curpos, horz_scale);
     }
     if (pTextAdvanceY) {
       *pTextAdvanceY = 0;
     }
     min_y = min_y * fontsize / 1000;
     max_y = max_y * fontsize / 1000;
   }
-  CFX_AffineMatrix matrix;
+  CFX_Matrix matrix;
   GetTextMatrix(&matrix);
   m_Left = min_x;
   m_Right = max_x;
   m_Bottom = min_y;
   m_Top = max_y;
   matrix.TransformRect(m_Left, m_Right, m_Top, m_Bottom);
   int textmode = m_TextState.GetObject()->m_TextMode;
   if (textmode == 1 || textmode == 2 || textmode == 5 || textmode == 6) {
     FX_FLOAT half_width = m_GraphState.GetObject()->m_LineWidth / 2;
     m_Left -= half_width;
@@ skipping 23 matching lines @@
       FX_WORD CID = pCIDFont->CIDFromCharCode(charcode);
       charwidth = pCIDFont->GetVertWidth(CID) * fontsize / 1000;
     } else {
       charwidth = pFont->GetCharWidthF(charcode) * fontsize / 1000;
     }
     pPosArray[index] = pPosArray[index - 1] + charwidth;
     index++;
   }
 }
 
-void CPDF_TextObject::Transform(const CFX_AffineMatrix& matrix) {
+void CPDF_TextObject::Transform(const CFX_Matrix& matrix) {
   m_TextState.GetModify();
-  CFX_AffineMatrix text_matrix;
+  CFX_Matrix text_matrix;
   GetTextMatrix(&text_matrix);
   text_matrix.Concat(matrix);
   FX_FLOAT* pTextMatrix = m_TextState.GetMatrix();
   pTextMatrix[0] = text_matrix.GetA();
   pTextMatrix[1] = text_matrix.GetC();
   pTextMatrix[2] = text_matrix.GetB();
   pTextMatrix[3] = text_matrix.GetD();
   m_PosX = text_matrix.GetE();
   m_PosY = text_matrix.GetF();
   CalcPositionData(nullptr, nullptr, 0);
@@ skipping 47 matching lines @@
   CPDF_ShadingObject* pSrcObj = (CPDF_ShadingObject*)pSrc;
   m_pShading = pSrcObj->m_pShading;
   if (m_pShading && m_pShading->m_pDocument) {
     CPDF_DocPageData* pDocPageData = m_pShading->m_pDocument->GetPageData();
     m_pShading = (CPDF_ShadingPattern*)pDocPageData->GetPattern(
         m_pShading->m_pShadingObj, m_pShading->m_bShadingObj,
         &m_pShading->m_ParentMatrix);
   }
   m_Matrix = pSrcObj->m_Matrix;
 }
-void CPDF_ShadingObject::Transform(const CFX_AffineMatrix& matrix) {
+void CPDF_ShadingObject::Transform(const CFX_Matrix& matrix) {
   if (!m_ClipPath.IsNull()) {
     m_ClipPath.GetModify();
     m_ClipPath.Transform(matrix);
   }
   m_Matrix.Concat(matrix);
   if (!m_ClipPath.IsNull()) {
     CalcBoundingBox();
   } else {
     matrix.TransformRect(m_Left, m_Right, m_Top, m_Bottom);
   }
 }
 void CPDF_ShadingObject::CalcBoundingBox() {
   if (m_ClipPath.IsNull()) {
     return;
   }
   CFX_FloatRect rect = m_ClipPath.GetClipBox();
   m_Left = rect.left;
   m_Bottom = rect.bottom;
   m_Right = rect.right;
   m_Top = rect.top;
 }
 CPDF_FormObject::~CPDF_FormObject() {
   delete m_pForm;
 }
-void CPDF_FormObject::Transform(const CFX_AffineMatrix& matrix) {
+void CPDF_FormObject::Transform(const CFX_Matrix& matrix) {
   m_FormMatrix.Concat(matrix);
   CalcBoundingBox();
 }
 void CPDF_FormObject::CopyData(const CPDF_PageObject* pSrc) {
   const CPDF_FormObject* pSrcObj = (const CPDF_FormObject*)pSrc;
   delete m_pForm;
   m_pForm = pSrcObj->m_pForm->Clone();
   m_FormMatrix = pSrcObj->m_FormMatrix;
 }
 void CPDF_FormObject::CalcBoundingBox() {
@@ skipping 56 matching lines @@
   }
   return -1;
 }
 CPDF_PageObject* CPDF_PageObjects::GetObjectByIndex(int index) const {
   FX_POSITION pos = m_ObjectList.FindIndex(index);
   if (pos == NULL) {
     return NULL;
   }
   return (CPDF_PageObject*)m_ObjectList.GetAt(pos);
 }
-void CPDF_PageObjects::Transform(const CFX_AffineMatrix& matrix) {
+void CPDF_PageObjects::Transform(const CFX_Matrix& matrix) {
   FX_POSITION pos = m_ObjectList.GetHeadPosition();
   while (pos) {
     CPDF_PageObject* pObj = (CPDF_PageObject*)m_ObjectList.GetNext(pos);
     pObj->Transform(matrix);
   }
 }
 CFX_FloatRect CPDF_PageObjects::CalcBoundingBox() const {
   if (m_ObjectList.GetCount() == 0) {
     return CFX_FloatRect(0, 0, 0, 0);
   }
@@ skipping 177 matching lines @@
     m_pResources = pParentResources;
   }
   if (m_pResources == NULL) {
     m_pResources = pPageResources;
   }
   m_Transparency = 0;
   LoadTransInfo();
 }
 CPDF_Form::~CPDF_Form() {}
 void CPDF_Form::StartParse(CPDF_AllStates* pGraphicStates,
-                           CFX_AffineMatrix* pParentMatrix,
+                           CFX_Matrix* pParentMatrix,
                            CPDF_Type3Char* pType3Char,
                            CPDF_ParseOptions* pOptions,
                            int level) {
   if (m_ParseState == CONTENT_PARSED || m_ParseState == CONTENT_PARSING) {
     return;
   }
   m_pParser = new CPDF_ContentParser;
   m_pParser->Start(this, pGraphicStates, pParentMatrix, pType3Char, pOptions,
                    level);
   m_ParseState = CONTENT_PARSING;
 }
 void CPDF_Form::ParseContent(CPDF_AllStates* pGraphicStates,
-                             CFX_AffineMatrix* pParentMatrix,
+                             CFX_Matrix* pParentMatrix,
                              CPDF_Type3Char* pType3Char,
                              CPDF_ParseOptions* pOptions,
                              int level) {
   StartParse(pGraphicStates, pParentMatrix, pType3Char, pOptions, level);
   ContinueParse(NULL);
 }
 CPDF_Form* CPDF_Form::Clone() const {
   CPDF_Form* pClone =
       new CPDF_Form(m_pDocument, m_pPageResources, m_pFormStream, m_pResources);
   FX_POSITION pos = m_ObjectList.GetHeadPosition();
   while (pos) {
     CPDF_PageObject* pObj = (CPDF_PageObject*)m_ObjectList.GetNext(pos);
     pClone->m_ObjectList.AddTail(pObj->Clone());
   }
   return pClone;
 }
-void CPDF_Page::GetDisplayMatrix(CFX_AffineMatrix& matrix,
+void CPDF_Page::GetDisplayMatrix(CFX_Matrix& matrix,
                                  int xPos,
                                  int yPos,
                                  int xSize,
                                  int ySize,
                                  int iRotate) const {
   if (m_PageWidth == 0 || m_PageHeight == 0) {
     return;
   }
-  CFX_AffineMatrix display_matrix;
+  CFX_Matrix display_matrix;
   int x0, y0, x1, y1, x2, y2;
   iRotate %= 4;
   switch (iRotate) {
     case 0:
       x0 = xPos;
       y0 = yPos + ySize;
       x1 = xPos;
       y1 = yPos;
       x2 = xPos + xSize;
       y2 = yPos + ySize;
@@ skipping 30 matching lines @@
                      (FX_FLOAT)y0);
   matrix = m_PageMatrix;
   matrix.Concat(display_matrix);
 }
 CPDF_ParseOptions::CPDF_ParseOptions() {
   m_bTextOnly = FALSE;
   m_bMarkedContent = TRUE;
   m_bSeparateForm = TRUE;
   m_bDecodeInlineImage = FALSE;
 }