Remove unneeded CPVT classes. (try 2)

core/fpdfdoc/cpdf_variabletext.cpp

 // Copyright 2016 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/fpdfdoc/include/cpdf_variabletext.h"
+
 #include "core/fpdfapi/fpdf_font/include/cpdf_font.h"
 #include "core/fpdfdoc/cpvt_wordinfo.h"
 #include "core/fpdfdoc/csection.h"
-#include "core/fpdfdoc/include/cpdf_variabletext.h"
 #include "core/fpdfdoc/include/cpvt_section.h"
 #include "core/fpdfdoc/include/cpvt_word.h"
 #include "core/fpdfdoc/include/ipvt_fontmap.h"
 
 namespace {
 
 const float kDefaultFontSize = 18.0f;
 const float kFontScale = 0.001f;
 const uint8_t kReturnLength = 1;
 const float kScalePercent = 0.01f;
@@ skipping 42 matching lines @@
       return 0;
   }
   if (CPDF_Font* pSysFont = m_pFontMap->GetPDFFont(1)) {
     if (pSysFont->CharCodeFromUnicode(word) != CPDF_Font::kInvalidCharCode)
       return 1;
   }
   return -1;
 }
 
 FX_BOOL CPDF_VariableText::Provider::IsLatinWord(uint16_t word) {
-  if ((word >= 0x61 && word <= 0x7A) || (word >= 0x41 && word <= 0x5A) ||
-      word == 0x2D || word == 0x27) {
-    return TRUE;
-  }
-  return FALSE;
+  return (word >= 0x61 && word <= 0x7A) || (word >= 0x41 && word <= 0x5A) ||
+         word == 0x2D || word == 0x27;
 }
 
 int32_t CPDF_VariableText::Provider::GetDefaultFontIndex() {
   return 0;
 }
 
 CPDF_VariableText::Iterator::Iterator(CPDF_VariableText* pVT)
     : m_CurPos(-1, -1, -1), m_pVT(pVT) {}
 
 CPDF_VariableText::Iterator::~Iterator() {}
@@ skipping 69 matching lines @@
   ASSERT(m_pVT);
   if (m_CurPos.nSecIndex > 0) {
     m_CurPos = CPVT_WordPlace(m_CurPos.nSecIndex - 1, 0, -1);
     return TRUE;
   }
   return FALSE;
 }
 
 FX_BOOL CPDF_VariableText::Iterator::GetWord(CPVT_Word& word) const {
   word.WordPlace = m_CurPos;
-  if (CSection* pSection = m_pVT->m_SectionArray.GetAt(m_CurPos.nSecIndex)) {
-    if (pSection->m_LineArray.GetAt(m_CurPos.nLineIndex)) {
-      if (CPVT_WordInfo* pWord =
-              pSection->m_WordArray.GetAt(m_CurPos.nWordIndex)) {
-        word.Word = pWord->Word;
-        word.nCharset = pWord->nCharset;
-        word.fWidth = m_pVT->GetWordWidth(*pWord);
-        word.ptWord = m_pVT->InToOut(
-            CFX_FloatPoint(pWord->fWordX + pSection->m_SecInfo.rcSection.left,
-                           pWord->fWordY + pSection->m_SecInfo.rcSection.top));
-        word.fAscent = m_pVT->GetWordAscent(*pWord);
-        word.fDescent = m_pVT->GetWordDescent(*pWord);
-        if (pWord->pWordProps)
-          word.WordProps = *pWord->pWordProps;
+  CSection* pSection = m_pVT->m_SectionArray.GetAt(m_CurPos.nSecIndex);
+  if (!pSection)
+    return FALSE;
 
-        word.nFontIndex = m_pVT->GetWordFontIndex(*pWord);
-        word.fFontSize = m_pVT->GetWordFontSize(*pWord);
-        return TRUE;
-      }
-    }
-  }
-  return FALSE;
+  if (!pSection->m_LineArray.GetAt(m_CurPos.nLineIndex))
+    return FALSE;
+
+  const CPVT_WordInfo* pWord = pSection->GetWord(m_CurPos.nWordIndex);
+  if (!pWord)
+    return FALSE;
+
+  word.Word = pWord->Word;
+  word.nCharset = pWord->nCharset;
+  word.fWidth = m_pVT->GetWordWidth(*pWord);
+  word.ptWord = m_pVT->InToOut(
+      CFX_FloatPoint(pWord->fWordX + pSection->m_SecInfo.rcSection.left,
+                     pWord->fWordY + pSection->m_SecInfo.rcSection.top));
+  word.fAscent = m_pVT->GetWordAscent(*pWord);
+  word.fDescent = m_pVT->GetWordDescent(*pWord);
+  if (pWord->pWordProps)
+    word.WordProps = *pWord->pWordProps;
+
+  word.nFontIndex = m_pVT->GetWordFontIndex(*pWord);
+  word.fFontSize = m_pVT->GetWordFontSize(*pWord);
+  return TRUE;
 }
 
 FX_BOOL CPDF_VariableText::Iterator::SetWord(const CPVT_Word& word) {
-  if (CSection* pSection = m_pVT->m_SectionArray.GetAt(m_CurPos.nSecIndex)) {
-    if (CPVT_WordInfo* pWord =
-            pSection->m_WordArray.GetAt(m_CurPos.nWordIndex)) {
-      if (pWord->pWordProps)
-        *pWord->pWordProps = word.WordProps;
-      return TRUE;
-    }
-  }
-  return FALSE;
+  CSection* pSection = m_pVT->m_SectionArray.GetAt(m_CurPos.nSecIndex);
+  if (!pSection)
+    return FALSE;
+
+  const CPVT_WordInfo* pWord = pSection->GetWord(m_CurPos.nWordIndex);
+  if (!pWord)
+    return FALSE;
+
+  if (pWord->pWordProps)
+    *pWord->pWordProps = word.WordProps;
+  return TRUE;
 }
 
 FX_BOOL CPDF_VariableText::Iterator::GetLine(CPVT_Line& line) const {
   ASSERT(m_pVT);
   line.lineplace = CPVT_WordPlace(m_CurPos.nSecIndex, m_CurPos.nLineIndex, -1);
   if (CSection* pSection = m_pVT->m_SectionArray.GetAt(m_CurPos.nSecIndex)) {
     if (CLine* pLine = pSection->m_LineArray.GetAt(m_CurPos.nLineIndex)) {
       line.ptLine = m_pVT->InToOut(CFX_FloatPoint(
           pLine->m_LineInfo.fLineX + pSection->m_SecInfo.rcSection.left,
           pLine->m_LineInfo.fLineY + pSection->m_SecInfo.rcSection.top));
@@ skipping 114 matching lines @@
   if (m_nLimitChar > 0 && nTotlaWords >= m_nLimitChar)
     return place;
   if (m_nCharArray > 0 && nTotlaWords >= m_nCharArray)
     return place;
   if (!m_bMultiLine)
     return place;
 
   CPVT_WordPlace wordplace = place;
   UpdateWordPlace(wordplace);
   CPVT_WordPlace newplace = place;
-  if (CSection* pSection = m_SectionArray.GetAt(wordplace.nSecIndex)) {
-    CPVT_WordPlace NewPlace(wordplace.nSecIndex + 1, 0, -1);
-    CPVT_SectionInfo secinfo;
-    if (m_bRichText) {
-      if (pSecProps)
-        secinfo.pSecProps = new CPVT_SecProps(*pSecProps);
-      if (pWordProps)
-        secinfo.pWordProps = new CPVT_WordProps(*pWordProps);
+  CSection* pSection = m_SectionArray.GetAt(wordplace.nSecIndex);
+  if (!pSection)
+    return newplace;
+
+  CPVT_WordPlace NewPlace(wordplace.nSecIndex + 1, 0, -1);
+  CPVT_SectionInfo secinfo;
+  if (m_bRichText) {
+    if (pSecProps)
+      secinfo.pSecProps = new CPVT_SecProps(*pSecProps);
+    if (pWordProps)
+      secinfo.pWordProps = new CPVT_WordProps(*pWordProps);
+  }
+  AddSection(NewPlace, secinfo);
+  newplace = NewPlace;
+  if (CSection* pNewSection = m_SectionArray.GetAt(NewPlace.nSecIndex)) {
+    for (int32_t i = wordplace.nWordIndex + 1; i < pSection->GetNumberOfWords();
+         ++i) {
+      const CPVT_WordInfo* pWord = pSection->GetWord(i);
+      NewPlace.nWordIndex++;
+      pNewSection->AddWord(NewPlace, *pWord);
     }
-    AddSection(NewPlace, secinfo);
-    newplace = NewPlace;
-    if (CSection* pNewSection = m_SectionArray.GetAt(NewPlace.nSecIndex)) {
-      for (int32_t w = wordplace.nWordIndex + 1,
-                   sz = pSection->m_WordArray.GetSize();
-           w < sz; w++) {
-        if (CPVT_WordInfo* pWord = pSection->m_WordArray.GetAt(w)) {
-          NewPlace.nWordIndex++;
-          pNewSection->AddWord(NewPlace, *pWord);
-        }
-      }
-    }
-    ClearSectionRightWords(wordplace);
   }
+  ClearSectionRightWords(wordplace);
   return newplace;
 }
 
 CPVT_WordPlace CPDF_VariableText::InsertText(const CPVT_WordPlace& place,
                                              const FX_WCHAR* text,
                                              int32_t charset,
                                              const CPVT_SecProps* pSecProps,
                                              const CPVT_WordProps* pProps) {
   CFX_WideString swText = text;
   CPVT_WordPlace wp = place;
@@ skipping 124 matching lines @@
 int32_t CPDF_VariableText::WordPlaceToWordIndex(
     const CPVT_WordPlace& place) const {
   CPVT_WordPlace newplace = place;
   UpdateWordPlace(newplace);
   int32_t nIndex = 0;
   int32_t i = 0;
   int32_t sz = 0;
   for (i = 0, sz = m_SectionArray.GetSize(); i < sz && i < newplace.nSecIndex;
        i++) {
     if (CSection* pSection = m_SectionArray.GetAt(i)) {
-      nIndex += pSection->m_WordArray.GetSize();
+      nIndex += pSection->GetNumberOfWords();
       if (i != m_SectionArray.GetSize() - 1)
         nIndex += kReturnLength;
     }
   }
   if (i >= 0 && i < m_SectionArray.GetSize())
     nIndex += newplace.nWordIndex + kReturnLength;
   return nIndex;
 }
 
 CPVT_WordPlace CPDF_VariableText::WordIndexToWordPlace(int32_t index) const {
   CPVT_WordPlace place = GetBeginWordPlace();
   int32_t nOldIndex = 0, nIndex = 0;
   FX_BOOL bFind = FALSE;
   for (int32_t i = 0, sz = m_SectionArray.GetSize(); i < sz; i++) {
     if (CSection* pSection = m_SectionArray.GetAt(i)) {
-      nIndex += pSection->m_WordArray.GetSize();
+      nIndex += pSection->GetNumberOfWords();
       if (nIndex == index) {
         place = pSection->GetEndWordPlace();
         bFind = TRUE;
         break;
-      } else if (nIndex > index) {
+      }
+      if (nIndex > index) {
         place.nSecIndex = i;
         place.nWordIndex = index - nOldIndex - 1;
         pSection->UpdateWordPlace(place);
         bFind = TRUE;
         break;
       }
       if (i != m_SectionArray.GetSize() - 1)
         nIndex += kReturnLength;
       nOldIndex = nIndex;
     }
@@ skipping 155 matching lines @@
     const CPVT_WordPlace& place) const {
   if (CSection* pSection = m_SectionArray.GetAt(place.nSecIndex))
     return pSection->GetEndWordPlace();
   return place;
 }
 
 int32_t CPDF_VariableText::GetTotalWords() const {
   int32_t nTotal = 0;
   for (int32_t i = 0, sz = m_SectionArray.GetSize(); i < sz; i++) {
     if (CSection* pSection = m_SectionArray.GetAt(i))
-      nTotal += (pSection->m_WordArray.GetSize() + kReturnLength);
+      nTotal += (pSection->GetNumberOfWords() + kReturnLength);
   }
 
   return nTotal - kReturnLength;
 }
 
 void CPDF_VariableText::ResetSectionArray() {
   for (int32_t s = 0, sz = m_SectionArray.GetSize(); s < sz; s++)
     delete m_SectionArray.GetAt(s);
 
   m_SectionArray.RemoveAll();
@@ skipping 12 matching lines @@
   if (nSecIndex == m_SectionArray.GetSize())
     m_SectionArray.Add(pSection);
   else
     m_SectionArray.InsertAt(nSecIndex, pSection);
 
   return place;
 }
 
 CPVT_WordPlace CPDF_VariableText::AddLine(const CPVT_WordPlace& place,
                                           const CPVT_LineInfo& lineinfo) {
-  if (m_SectionArray.IsEmpty())
+  if (m_SectionArray.GetSize() == 0)
     return place;
   if (CSection* pSection = m_SectionArray.GetAt(place.nSecIndex))
     return pSection->AddLine(lineinfo);
   return place;
 }
 
 CPVT_WordPlace CPDF_VariableText::AddWord(const CPVT_WordPlace& place,
                                           const CPVT_WordInfo& wordinfo) {
-  if (m_SectionArray.GetSize() <= 0) {
+  if (m_SectionArray.GetSize() <= 0)
     return place;
-  }
+
   CPVT_WordPlace newplace = place;
   newplace.nSecIndex =
       std::max(std::min(newplace.nSecIndex, m_SectionArray.GetSize() - 1), 0);
   if (CSection* pSection = m_SectionArray.GetAt(newplace.nSecIndex))
     return pSection->AddWord(newplace, wordinfo);
   return place;
 }
 
 FX_BOOL CPDF_VariableText::GetWordInfo(const CPVT_WordPlace& place,
                                        CPVT_WordInfo& wordinfo) {
-  if (CSection* pSection = m_SectionArray.GetAt(place.nSecIndex)) {
-    if (CPVT_WordInfo* pWord = pSection->m_WordArray.GetAt(place.nWordIndex)) {
-      wordinfo = *pWord;
-      return TRUE;
-    }
-  }
-  return FALSE;
+  CSection* pSection = m_SectionArray.GetAt(place.nSecIndex);
+  if (!pSection)
+    return FALSE;
+
+  const CPVT_WordInfo* pWord = pSection->GetWord(place.nWordIndex);
+  if (!pWord)
+    return FALSE;
+
+  wordinfo = *pWord;
+  return TRUE;
 }
 
 FX_BOOL CPDF_VariableText::SetWordInfo(const CPVT_WordPlace& place,
                                        const CPVT_WordInfo& wordinfo) {
-  if (CSection* pSection = m_SectionArray.GetAt(place.nSecIndex)) {
-    if (CPVT_WordInfo* pWord = pSection->m_WordArray.GetAt(place.nWordIndex)) {
-      *pWord = wordinfo;
-      return TRUE;
-    }
-  }
-  return FALSE;
+  CSection* pSection = m_SectionArray.GetAt(place.nSecIndex);
+  if (!pSection)
+    return FALSE;
+
+  CPVT_WordInfo* pWord = pSection->GetWord(place.nWordIndex);
+  if (!pWord)
+    return FALSE;
+
+  *pWord = wordinfo;
+  return TRUE;
 }
 
 FX_BOOL CPDF_VariableText::GetLineInfo(const CPVT_WordPlace& place,
                                        CPVT_LineInfo& lineinfo) {
   if (CSection* pSection = m_SectionArray.GetAt(place.nSecIndex)) {
     if (CLine* pLine = pSection->m_LineArray.GetAt(place.nLineIndex)) {
       lineinfo = pLine->m_LineInfo;
       return TRUE;
     }
   }
@@ skipping 117 matching lines @@
                                             : m_fCharSpace;
 }
 
 int32_t CPDF_VariableText::GetHorzScale(const CPVT_WordInfo& WordInfo) {
   return m_bRichText && WordInfo.pWordProps ? WordInfo.pWordProps->nHorzScale
                                             : m_nHorzScale;
 }
 
 void CPDF_VariableText::ClearSectionRightWords(const CPVT_WordPlace& place) {
   CPVT_WordPlace wordplace = AdjustLineHeader(place, TRUE);
-  if (CSection* pSection = m_SectionArray.GetAt(place.nSecIndex)) {
-    for (int32_t w = pSection->m_WordArray.GetSize() - 1;
-         w > wordplace.nWordIndex; w--) {
-      delete pSection->m_WordArray.GetAt(w);
-      pSection->m_WordArray.RemoveAt(w);
-    }
-  }
+  CSection* pSection = m_SectionArray.GetAt(place.nSecIndex);
+  if (pSection)
+    pSection->ClearRightWords(wordplace.nWordIndex);

[dsinclair, 2016/05/16 14:12:27]

ClearRightWords is ... confusing. ClearWordsFrom maybe?

 }
 
 CPVT_WordPlace CPDF_VariableText::AdjustLineHeader(const CPVT_WordPlace& place,
                                                    FX_BOOL bPrevOrNext) const {
   if (place.nWordIndex < 0 && place.nLineIndex > 0)
     return bPrevOrNext ? GetPrevWordPlace(place) : GetNextWordPlace(place);
   return place;
 }
 
 FX_BOOL CPDF_VariableText::ClearEmptySection(const CPVT_WordPlace& place) {
   if (place.nSecIndex == 0 && m_SectionArray.GetSize() == 1)
     return FALSE;
   if (CSection* pSection = m_SectionArray.GetAt(place.nSecIndex)) {
-    if (pSection->m_WordArray.GetSize() == 0) {
+    if (pSection->IsWordArrayEmpty()) {

[dsinclair, 2016/05/16 14:12:27]

Can this use GetSize() == 0? We got rid of IsEmpty on the SectionArray but then
added it on the WordArray. Would be nice if they were consistent.

       delete pSection;
       m_SectionArray.RemoveAt(place.nSecIndex);
       return TRUE;
     }
   }
   return FALSE;
 }
 
 void CPDF_VariableText::ClearEmptySections(const CPVT_WordRange& PlaceRange) {
   CPVT_WordPlace wordplace;
   for (int32_t s = PlaceRange.EndPos.nSecIndex;
        s > PlaceRange.BeginPos.nSecIndex; s--) {
     wordplace.nSecIndex = s;
     ClearEmptySection(wordplace);
   }
 }
 
 void CPDF_VariableText::LinkLatterSection(const CPVT_WordPlace& place) {
   CPVT_WordPlace oldplace = AdjustLineHeader(place, TRUE);
   if (CSection* pNextSection = m_SectionArray.GetAt(place.nSecIndex + 1)) {
     if (CSection* pSection = m_SectionArray.GetAt(oldplace.nSecIndex)) {
-      for (int32_t w = 0, sz = pNextSection->m_WordArray.GetSize(); w < sz;
-           w++) {
-        if (CPVT_WordInfo* pWord = pNextSection->m_WordArray.GetAt(w)) {
-          oldplace.nWordIndex++;
-          pSection->AddWord(oldplace, *pWord);
-        }
+      for (int32_t i = 0; i < pNextSection->GetNumberOfWords(); ++i) {
+        const CPVT_WordInfo* pWord = pNextSection->GetWord(i);

[dsinclair, 2016/05/16 14:12:27]

It's no longer possible for pWord to be nullptr?

+        oldplace.nWordIndex++;
+        pSection->AddWord(oldplace, *pWord);
       }
     }
     delete pNextSection;
     m_SectionArray.RemoveAt(place.nSecIndex + 1);
   }
 }
 
 void CPDF_VariableText::ClearWords(const CPVT_WordRange& PlaceRange) {
   CPVT_WordRange NewRange;
   NewRange.BeginPos = AdjustLineHeader(PlaceRange.BeginPos, TRUE);
   NewRange.EndPos = AdjustLineHeader(PlaceRange.EndPos, TRUE);
   for (int32_t s = NewRange.EndPos.nSecIndex; s >= NewRange.BeginPos.nSecIndex;
        s--) {
     if (CSection* pSection = m_SectionArray.GetAt(s))
       pSection->ClearWords(NewRange);
   }
 }
 
 CPVT_WordPlace CPDF_VariableText::ClearLeftWord(const CPVT_WordPlace& place) {
   if (CSection* pSection = m_SectionArray.GetAt(place.nSecIndex)) {
     CPVT_WordPlace leftplace = GetPrevWordPlace(place);
     if (leftplace != place) {
       if (leftplace.nSecIndex != place.nSecIndex) {
-        if (pSection->m_WordArray.GetSize() == 0)
+        if (pSection->IsWordArrayEmpty())
           ClearEmptySection(place);
         else
           LinkLatterSection(leftplace);
       } else {
         pSection->ClearWord(place);
       }
     }
     return leftplace;
   }
   return place;
@@ skipping 55 matching lines @@
       continue;
     } else {
       nLeft = nMid + 1;
       nMid = (nLeft + nRight) / 2;
       continue;
     }
   }
   return (FX_FLOAT)gFontSizeSteps[nMid];
 }
 
-FX_BOOL CPDF_VariableText::IsBigger(FX_FLOAT fFontSize) {
-  FX_BOOL bBigger = FALSE;
-  CPVT_Size szTotal;
+bool CPDF_VariableText::IsBigger(FX_FLOAT fFontSize) const {
+  CFX_PointF szTotal;
   for (int32_t s = 0, sz = m_SectionArray.GetSize(); s < sz; s++) {
     if (CSection* pSection = m_SectionArray.GetAt(s)) {
-      CPVT_Size size = pSection->GetSectionSize(fFontSize);
+      CFX_PointF size = pSection->GetSectionSize(fFontSize);
       szTotal.x = std::max(size.x, szTotal.x);
       szTotal.y += size.y;
       if (IsFloatBigger(szTotal.x, GetPlateWidth()) ||
           IsFloatBigger(szTotal.y, GetPlateHeight())) {
-        bBigger = TRUE;
-        break;
+        return true;
       }
     }
   }
-  return bBigger;
+  return false;
 }
 
 CPVT_FloatRect CPDF_VariableText::RearrangeSections(
     const CPVT_WordRange& PlaceRange) {
   CPVT_WordPlace place;
   FX_FLOAT fPosY = 0;
   FX_FLOAT fOldHeight;
   int32_t nSSecIndex = PlaceRange.BeginPos.nSecIndex;
   int32_t nESecIndex = PlaceRange.EndPos.nSecIndex;
   CPVT_FloatRect rcRet;
@@ skipping 70 matching lines @@
     m_pVTIterator = new CPDF_VariableText::Iterator(this);
   return m_pVTIterator;
 }
 
 CPDF_VariableText::Provider* CPDF_VariableText::SetProvider(
     CPDF_VariableText::Provider* pProvider) {
   CPDF_VariableText::Provider* pOld = m_pVTProvider;
   m_pVTProvider = pProvider;
   return pOld;
 }