Merge to XFA: Get rid of most uses of CFX_PtrArray.

core/src/fpdftext/fpdf_text.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 "core/include/fpdfapi/fpdf_page.h"
 #include "core/include/fpdfapi/fpdf_pageobj.h"
 #include "core/include/fpdfapi/fpdf_resource.h"
 #include "core/include/fpdftext/fpdf_text.h"
@@ skipping 23 matching lines @@
   if (ret && !iDef) {
     return CFX_ByteString(buf, ret);
   }
   const FX_CHAR* altstr = FCS_GetAltStr(unicode);
   return CFX_ByteString(altstr ? altstr : defchar);
 }
 CTextPage::CTextPage() {}
 CTextPage::~CTextPage() {
   int i;
   for (i = 0; i < m_BaseLines.GetSize(); i++) {
-    CTextBaseLine* pBaseLine = (CTextBaseLine*)m_BaseLines.GetAt(i);
-    delete pBaseLine;
+    delete m_BaseLines.GetAt(i);
   }
   for (i = 0; i < m_TextColumns.GetSize(); i++) {
-    CTextColumn* pTextColumn = (CTextColumn*)m_TextColumns.GetAt(i);
-    delete pTextColumn;
+    delete m_TextColumns.GetAt(i);
   }
 }
 void CTextPage::ProcessObject(CPDF_PageObject* pObject) {
   if (pObject->m_Type != PDFPAGE_TEXT) {
     return;
   }
   CPDF_TextObject* pText = (CPDF_TextObject*)pObject;
   CPDF_Font* pFont = pText->m_TextState.GetFont();
   int count = pText->CountItems();
   FX_FLOAT* pPosArray = FX_Alloc2D(FX_FLOAT, count, 2);
@@ skipping 106 matching lines @@
                                         FX_FLOAT spacew,
                                         FX_FLOAT fontsize_v,
                                         CFX_ByteString& str,
                                         CPDF_Font* pFont) {
   if (str.GetLength() == 0) {
     return NULL;
   }
   if (pBaseLine == NULL) {
     int i;
     for (i = 0; i < m_BaseLines.GetSize(); i++) {
-      CTextBaseLine* pExistLine = (CTextBaseLine*)m_BaseLines.GetAt(i);
+      CTextBaseLine* pExistLine = m_BaseLines.GetAt(i);
       if (pExistLine->m_BaseLine == basey) {
         pBaseLine = pExistLine;
         break;
       }
       if (pExistLine->m_BaseLine < basey) {
         break;
       }
     }
     if (pBaseLine == NULL) {
       pBaseLine = new CTextBaseLine;
@@ skipping 17 matching lines @@
                            text);
   return pBaseLine;
 }
 void CTextPage::WriteOutput(CFX_WideStringArray& lines, int iMinWidth) {
   FX_FLOAT lastheight = -1;
   FX_FLOAT lastbaseline = -1;
   FX_FLOAT MinLeftX = 1000000;
   FX_FLOAT MaxRightX = 0;
   int i;
   for (i = 0; i < m_BaseLines.GetSize(); i++) {
-    CTextBaseLine* pBaseLine = (CTextBaseLine*)m_BaseLines.GetAt(i);
+    CTextBaseLine* pBaseLine = m_BaseLines.GetAt(i);
     FX_FLOAT leftx, rightx;
     if (pBaseLine->GetWidth(leftx, rightx)) {
       if (leftx < MinLeftX) {
         MinLeftX = leftx;
       }
       if (rightx > MaxRightX) {
         MaxRightX = rightx;
       }
     }
   }
   for (i = 0; i < m_BaseLines.GetSize(); i++) {
-    CTextBaseLine* pBaseLine = (CTextBaseLine*)m_BaseLines.GetAt(i);
-    pBaseLine->MergeBoxes();
+    m_BaseLines.GetAt(i)->MergeBoxes();
   }
   for (i = 1; i < m_BaseLines.GetSize(); i++) {
-    CTextBaseLine* pBaseLine = (CTextBaseLine*)m_BaseLines.GetAt(i);
-    CTextBaseLine* pPrevLine = (CTextBaseLine*)m_BaseLines.GetAt(i - 1);
+    CTextBaseLine* pBaseLine = m_BaseLines.GetAt(i);
+    CTextBaseLine* pPrevLine = m_BaseLines.GetAt(i - 1);
     if (pBaseLine->CanMerge(pPrevLine)) {
       pPrevLine->Merge(pBaseLine);
       delete pBaseLine;
       m_BaseLines.RemoveAt(i);
       i--;
     }
   }
   if (m_bAutoWidth) {
     int* widths = FX_Alloc(int, m_BaseLines.GetSize());
     for (i = 0; i < m_BaseLines.GetSize(); i++) {
       widths[i] = 0;
-      CTextBaseLine* pBaseLine = (CTextBaseLine*)m_BaseLines.GetAt(i);
+      CTextBaseLine* pBaseLine = m_BaseLines.GetAt(i);
       int TotalChars = 0;
       FX_FLOAT TotalWidth = 0;
       int minchars;
       pBaseLine->CountChars(TotalChars, TotalWidth, minchars);
       if (TotalChars) {
         FX_FLOAT charwidth = TotalWidth / TotalChars;
         widths[i] = (int)((MaxRightX - MinLeftX) / charwidth);
       }
       if (widths[i] > 1000) {
         widths[i] = 1000;
@@ skipping 16 matching lines @@
       }
     if (MaxWidth > AvgWidth * 6 / 5) {
       MaxWidth = AvgWidth * 6 / 5;
     }
     FX_Free(widths);
     if (iMinWidth < MaxWidth) {
       iMinWidth = MaxWidth;
     }
   }
   for (i = 0; i < m_BaseLines.GetSize(); i++) {
-    CTextBaseLine* pBaseLine = (CTextBaseLine*)m_BaseLines.GetAt(i);
-    pBaseLine->MergeBoxes();
+    m_BaseLines.GetAt(i)->MergeBoxes();
   }
   if (m_bKeepColumn) {
     FindColumns();
   }
   for (i = 0; i < m_BaseLines.GetSize(); i++) {
-    CTextBaseLine* pBaseLine = (CTextBaseLine*)m_BaseLines.GetAt(i);
+    CTextBaseLine* pBaseLine = m_BaseLines.GetAt(i);
     if (lastheight >= 0) {
       FX_FLOAT dy = lastbaseline - pBaseLine->m_BaseLine;
       if (dy >= (pBaseLine->m_MaxFontSizeV) * 1.5 || dy >= lastheight * 1.5) {
         lines.Add(L"");
       }
     }
     lastheight = pBaseLine->m_MaxFontSizeV;
     lastbaseline = pBaseLine->m_BaseLine;
     CFX_WideString str;
     pBaseLine->WriteOutput(str, MinLeftX, MaxRightX - MinLeftX, iMinWidth);
@@ skipping 143 matching lines @@
     FX_WCHAR ch = str[i];
     // TODO(dsinclair): --.+ +.-- should probably not be a number.
     if (!std::iswdigit(ch) && ch != '-' && ch != '+' && ch != '.' && ch != ' ')
       return FALSE;
   }
   return TRUE;
 }
 void CTextPage::FindColumns() {
   int i;
   for (i = 0; i < m_BaseLines.GetSize(); i++) {
-    CTextBaseLine* pBaseLine = (CTextBaseLine*)m_BaseLines.GetAt(i);
+    CTextBaseLine* pBaseLine = m_BaseLines.GetAt(i);
     for (int j = 0; j < pBaseLine->m_TextList.GetSize(); j++) {
-      CTextBox* pTextBox = (CTextBox*)pBaseLine->m_TextList.GetAt(j);
+      CTextBox* pTextBox = pBaseLine->m_TextList.GetAt(j);
       CTextColumn* pColumn = FindColumn(pTextBox->m_Right);
       if (pColumn == NULL) {
         pColumn = new CTextColumn;
         pColumn->m_Count = 1;
         pColumn->m_AvgPos = pTextBox->m_Right;
         pColumn->m_TextPos = -1;
         m_TextColumns.Add(pColumn);
       } else {
         pColumn->m_AvgPos =
             (pColumn->m_Count * pColumn->m_AvgPos + pTextBox->m_Right) /
             (pColumn->m_Count + 1);
         pColumn->m_Count++;
       }
     }
   }
   int mincount = m_BaseLines.GetSize() / 4;
   for (i = 0; i < m_TextColumns.GetSize(); i++) {
-    CTextColumn* pTextColumn = (CTextColumn*)m_TextColumns.GetAt(i);
+    CTextColumn* pTextColumn = m_TextColumns.GetAt(i);
     if (pTextColumn->m_Count >= mincount) {
       continue;
     }
     delete pTextColumn;
     m_TextColumns.RemoveAt(i);
     i--;
   }
   for (i = 0; i < m_BaseLines.GetSize(); i++) {
-    CTextBaseLine* pBaseLine = (CTextBaseLine*)m_BaseLines.GetAt(i);
+    CTextBaseLine* pBaseLine = m_BaseLines.GetAt(i);
     for (int j = 0; j < pBaseLine->m_TextList.GetSize(); j++) {
-      CTextBox* pTextBox = (CTextBox*)pBaseLine->m_TextList.GetAt(j);
+      CTextBox* pTextBox = pBaseLine->m_TextList.GetAt(j);
       if (IsNumber(pTextBox->m_Text)) {
         pTextBox->m_pColumn = FindColumn(pTextBox->m_Right);
       }
     }
   }
 }
 CTextColumn* CTextPage::FindColumn(FX_FLOAT xpos) {
   for (int i = 0; i < m_TextColumns.GetSize(); i++) {
-    CTextColumn* pColumn = (CTextColumn*)m_TextColumns.GetAt(i);
+    CTextColumn* pColumn = m_TextColumns.GetAt(i);
     if (pColumn->m_AvgPos < xpos + 1 && pColumn->m_AvgPos > xpos - 1) {
       return pColumn;
     }
   }
   return NULL;
 }
 void CTextPage::BreakSpace(CPDF_TextObject* pTextObj) {}
 CTextBaseLine::CTextBaseLine() {
   m_Top = -100000;
   m_Bottom = 100000;
   m_MaxFontSizeV = 0;
 }
 CTextBaseLine::~CTextBaseLine() {
   for (int i = 0; i < m_TextList.GetSize(); i++) {
-    CTextBox* pText = (CTextBox*)m_TextList.GetAt(i);
-    delete pText;
+    delete m_TextList.GetAt(i);
   }
 }
 void CTextBaseLine::InsertTextBox(FX_FLOAT leftx,
                                   FX_FLOAT rightx,
                                   FX_FLOAT topy,
                                   FX_FLOAT bottomy,
                                   FX_FLOAT spacew,
                                   FX_FLOAT fontsize_v,
                                   const CFX_WideString& text) {
   if (m_Top < topy) {
     m_Top = topy;
   }
   if (m_Bottom > bottomy) {
     m_Bottom = bottomy;
   }
   if (m_MaxFontSizeV < fontsize_v) {
     m_MaxFontSizeV = fontsize_v;
   }
   int i;
   for (i = 0; i < m_TextList.GetSize(); i++) {
-    CTextBox* pText = (CTextBox*)m_TextList.GetAt(i);
+    CTextBox* pText = m_TextList.GetAt(i);
     if (pText->m_Left > leftx) {
       break;
     }
   }
   CTextBox* pText = new CTextBox;
   pText->m_Text = text;
   pText->m_Left = leftx;
   pText->m_Right = rightx;
   pText->m_Top = topy;
   pText->m_Bottom = bottomy;
@@ skipping 14 matching lines @@
                        inter_bottom, inter_top)) {
     return FALSE;
   }
   FX_FLOAT inter_h = inter_top - inter_bottom;
   if (inter_h < (m_Top - m_Bottom) / 2 &&
       inter_h < (pOther->m_Top - pOther->m_Bottom) / 2) {
     return FALSE;
   }
   FX_FLOAT dy = (FX_FLOAT)FXSYS_fabs(m_BaseLine - pOther->m_BaseLine);
   for (int i = 0; i < m_TextList.GetSize(); i++) {
-    CTextBox* pText = (CTextBox*)m_TextList.GetAt(i);
+    CTextBox* pText = m_TextList.GetAt(i);
     for (int j = 0; j < pOther->m_TextList.GetSize(); j++) {
-      CTextBox* pOtherText = (CTextBox*)pOther->m_TextList.GetAt(j);
+      CTextBox* pOtherText = pOther->m_TextList.GetAt(j);
       FX_FLOAT inter_left, inter_right;
       if (!GetIntersection(pText->m_Left, pText->m_Right, pOtherText->m_Left,
                            pOtherText->m_Right, inter_left, inter_right)) {
         continue;
       }
       FX_FLOAT inter_w = inter_right - inter_left;
       if (inter_w < pText->m_SpaceWidth / 2 &&
           inter_w < pOtherText->m_SpaceWidth / 2) {
         continue;
       }
       if (dy >= (pText->m_Bottom - pText->m_Top) / 2 ||
           dy >= (pOtherText->m_Bottom - pOtherText->m_Top) / 2) {
         return FALSE;
       }
     }
   }
   return TRUE;
 }
 void CTextBaseLine::Merge(CTextBaseLine* pOther) {
   for (int i = 0; i < pOther->m_TextList.GetSize(); i++) {
-    CTextBox* pText = (CTextBox*)pOther->m_TextList.GetAt(i);
+    CTextBox* pText = pOther->m_TextList.GetAt(i);
     InsertTextBox(pText->m_Left, pText->m_Right, pText->m_Top, pText->m_Bottom,
                   pText->m_SpaceWidth, pText->m_FontSizeV, pText->m_Text);
   }
 }
 FX_BOOL CTextBaseLine::GetWidth(FX_FLOAT& leftx, FX_FLOAT& rightx) {
   int i;
   for (i = 0; i < m_TextList.GetSize(); i++) {
-    CTextBox* pText = (CTextBox*)m_TextList.GetAt(i);
+    CTextBox* pText = m_TextList.GetAt(i);
     if (pText->m_Text != L" ") {
       break;
     }
   }
   if (i == m_TextList.GetSize()) {
     return FALSE;
   }
-  CTextBox* pText = (CTextBox*)m_TextList.GetAt(i);
+  CTextBox* pText = m_TextList.GetAt(i);
   leftx = pText->m_Left;
   for (i = m_TextList.GetSize() - 1; i >= 0; i--) {
-    CTextBox* pText = (CTextBox*)m_TextList.GetAt(i);
+    CTextBox* pText = m_TextList.GetAt(i);
     if (pText->m_Text != L" ") {
       break;
     }
   }
-  pText = (CTextBox*)m_TextList.GetAt(i);
+  pText = m_TextList.GetAt(i);
   rightx = pText->m_Right;
   return TRUE;
 }
 void CTextBaseLine::MergeBoxes() {
   int i = 0;
   while (1) {
     if (i >= m_TextList.GetSize() - 1) {
       break;
     }
-    CTextBox* pThisText = (CTextBox*)m_TextList.GetAt(i);
-    CTextBox* pNextText = (CTextBox*)m_TextList.GetAt(i + 1);
+    CTextBox* pThisText = m_TextList.GetAt(i);
+    CTextBox* pNextText = m_TextList.GetAt(i + 1);
     FX_FLOAT dx = pNextText->m_Left - pThisText->m_Right;
     FX_FLOAT spacew = (pThisText->m_SpaceWidth == 0.0)
                           ? pNextText->m_SpaceWidth
                           : pThisText->m_SpaceWidth;
     if (spacew > 0.0 && dx < spacew * 2) {
       pThisText->m_Right = pNextText->m_Right;
       if (dx > spacew * 1.5) {
         pThisText->m_Text += L"  ";
       } else if (dx > spacew / 3) {
         pThisText->m_Text += L' ';
       }
       pThisText->m_Text += pNextText->m_Text;
       pThisText->m_SpaceWidth =
           pNextText->m_SpaceWidth == 0.0 ? spacew : pNextText->m_SpaceWidth;
       m_TextList.RemoveAt(i + 1);
       delete pNextText;
     } else {
       i++;
     }
   }
 }
 void CTextBaseLine::WriteOutput(CFX_WideString& str,
                                 FX_FLOAT leftx,
                                 FX_FLOAT pagewidth,
                                 int iTextWidth) {
   int lastpos = -1;
   for (int i = 0; i < m_TextList.GetSize(); i++) {
-    CTextBox* pText = (CTextBox*)m_TextList.GetAt(i);
+    CTextBox* pText = m_TextList.GetAt(i);
     int xpos;
     if (pText->m_pColumn) {
       xpos =
           (int)((pText->m_pColumn->m_AvgPos - leftx) * iTextWidth / pagewidth +
                 0.5);
       xpos -= pText->m_Text.GetLength();
     } else {
       xpos = (int)((pText->m_Left - leftx) * iTextWidth / pagewidth + 0.5);
     }
     if (xpos <= lastpos) {
       xpos = lastpos + 1;
     }
     for (int j = lastpos + 1; j < xpos; j++) {
       str += ' ';
     }
     CFX_WideString sSrc(pText->m_Text);
     NormalizeString(sSrc);
     str += sSrc;
     str += ' ';
     lastpos = xpos + pText->m_Text.GetLength();
   }
 }
 void CTextBaseLine::CountChars(int& count, FX_FLOAT& width, int& minchars) {
   minchars = 0;
   for (int i = 0; i < m_TextList.GetSize(); i++) {
-    CTextBox* pText = (CTextBox*)m_TextList.GetAt(i);
+    CTextBox* pText = m_TextList.GetAt(i);
     if (pText->m_Right - pText->m_Left < 0.002) {
       continue;
     }
     count += pText->m_Text.GetLength();
     width += pText->m_Right - pText->m_Left;
     minchars += pText->m_Text.GetLength() + 1;
   }
 }
 #define PI 3.1415926535897932384626433832795
 static void CheckRotate(CPDF_Page& page, CFX_FloatRect& page_bbox) {
@@ skipping 99 matching lines @@
                                FX_DWORD flags) {
   buffer.EstimateSize(0, 10240);
   CPDF_Page page;
   page.Load(pDoc, pPage);
   CPDF_ParseOptions options;
   options.m_bTextOnly = TRUE;
   options.m_bSeparateForm = FALSE;
   page.ParseContent(&options);
   GetTextStream_Unicode(buffer, &page, TRUE, NULL);
 }