Switch most min/max macros to std::min/max.

core/src/fpdfdoc/doc_vt.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 "core/include/fpdfdoc/fpdf_doc.h"
 #include "core/include/fpdfdoc/fpdf_vt.h"
 #include "pdf_vt.h"
 
 const uint8_t gFontSizeSteps[] = {4,  6,  8,   9,   10,  12,  14, 18, 20,
                                   25, 30, 35,  40,  45,  50,  55, 60, 70,
                                   80, 90, 100, 110, 120, 130, 144};
 #define PVT_RETURN_LENGTH 1
 #define PVT_DEFAULT_FONTSIZE 18.0f
 #define PVTWORD_SCRIPT_NORMAL 0
@@ skipping 48 matching lines @@
   for (int32_t i = 0, sz = m_LineArray.GetSize(); i < sz; i++) {
     if (CLine* pLine = m_LineArray.GetAt(i)) {
       pLine->LinePlace = CPVT_WordPlace(SecPlace.nSecIndex, i, -1);
     }
   }
 }
 CPVT_WordPlace CSection::AddWord(const CPVT_WordPlace& place,
                                  const CPVT_WordInfo& wordinfo) {
   CPVT_WordInfo* pWord = new CPVT_WordInfo(wordinfo);
   int32_t nWordIndex =
-      FPDF_MAX(FPDF_MIN(place.nWordIndex, m_WordArray.GetSize()), 0);
+      std::max(std::min(place.nWordIndex, m_WordArray.GetSize()), 0);
   if (nWordIndex == m_WordArray.GetSize()) {
     m_WordArray.Add(pWord);
   } else {
     m_WordArray.InsertAt(nWordIndex, pWord);
   }
   return place;
 }
 CPVT_WordPlace CSection::AddLine(const CPVT_LineInfo& lineinfo) {
   return CPVT_WordPlace(SecPlace.nSecIndex, m_LineArray.Add(lineinfo), -1);
 }
@@ skipping 263 matching lines @@
         pWord->fWordTail = 0;
         FX_FLOAT fWordWidth = m_pVT->GetWordWidth(*pWord);
         FX_FLOAT fWordAscent = m_pVT->GetWordAscent(*pWord);
         FX_FLOAT fWordDescent = m_pVT->GetWordDescent(*pWord);
         x = (FX_FLOAT)(fNodeWidth * (w + nStart + 0.5) - fWordWidth * PVT_HALF);
         pWord->fWordX = x;
         pWord->fWordY = y;
         if (w == 0) {
           pLine->m_LineInfo.fLineX = x;
         }
-        if (w != m_pSection->m_WordArray.GetSize() - 1)
+        if (w != m_pSection->m_WordArray.GetSize() - 1) {
           pWord->fWordTail =
               (fNodeWidth - (fWordWidth + fNextWidth) * PVT_HALF > 0
                    ? fNodeWidth - (fWordWidth + fNextWidth) * PVT_HALF
                    : 0);
-        else {
+        } else {
           pWord->fWordTail = 0;
         }
         x += fWordWidth;
-        fLineAscent = FPDF_MAX(fLineAscent, fWordAscent);
-        fLineDescent = FPDF_MIN(fLineDescent, fWordDescent);
+        fLineAscent = std::max(fLineAscent, fWordAscent);
+        fLineDescent = std::min(fLineDescent, fWordDescent);
       }
     }
     pLine->m_LineInfo.nBeginWordIndex = 0;
     pLine->m_LineInfo.nEndWordIndex = m_pSection->m_WordArray.GetSize() - 1;
     pLine->m_LineInfo.fLineY = y;
     pLine->m_LineInfo.fLineWidth = x - pLine->m_LineInfo.fLineX;
     pLine->m_LineInfo.fLineAscent = fLineAscent;
     pLine->m_LineInfo.fLineDescent = fLineDescent;
     y += (-fLineDescent);
   }
@@ skipping 195 matching lines @@
   FX_FLOAT fMaxX = 0.0f, fMaxY = 0.0f;
   FX_FLOAT fLineWidth = 0.0f, fBackupLineWidth = 0.0f;
   FX_FLOAT fLineAscent = 0.0f, fBackupLineAscent = 0.0f;
   FX_FLOAT fLineDescent = 0.0f, fBackupLineDescent = 0.0f;
   int32_t nWordStartPos = 0;
   FX_BOOL bFullWord = FALSE;
   int32_t nLineFullWordIndex = 0;
   int32_t nCharIndex = 0;
   CPVT_LineInfo line;
   FX_FLOAT fWordWidth = 0;
-  FX_FLOAT fTypesetWidth = FPDF_MAX(
+  FX_FLOAT fTypesetWidth = std::max(
       m_pVT->GetPlateWidth() - m_pVT->GetLineIndent(m_pSection->m_SecInfo),
       0.0f);
   int32_t nTotalWords = m_pSection->m_WordArray.GetSize();
   FX_BOOL bOpened = FALSE;
   if (nTotalWords > 0) {
     int32_t i = 0;
     while (i < nTotalWords) {
       CPVT_WordInfo* pWord = m_pSection->m_WordArray.GetAt(i);
       CPVT_WordInfo* pOldWord = pWord;
       if (i > 0) {
         pOldWord = m_pSection->m_WordArray.GetAt(i - 1);
       }
       if (pWord) {
         if (bTypeset) {
           fLineAscent =
-              FPDF_MAX(fLineAscent, m_pVT->GetWordAscent(*pWord, TRUE));
+              std::max(fLineAscent, m_pVT->GetWordAscent(*pWord, TRUE));
           fLineDescent =
-              FPDF_MIN(fLineDescent, m_pVT->GetWordDescent(*pWord, TRUE));
+              std::min(fLineDescent, m_pVT->GetWordDescent(*pWord, TRUE));
           fWordWidth = m_pVT->GetWordWidth(*pWord);
         } else {
           fLineAscent =
-              FPDF_MAX(fLineAscent, m_pVT->GetWordAscent(*pWord, fFontSize));
+              std::max(fLineAscent, m_pVT->GetWordAscent(*pWord, fFontSize));
           fLineDescent =
-              FPDF_MIN(fLineDescent, m_pVT->GetWordDescent(*pWord, fFontSize));
+              std::min(fLineDescent, m_pVT->GetWordDescent(*pWord, fFontSize));
           fWordWidth = m_pVT->GetWordWidth(
               pWord->nFontIndex, pWord->Word, m_pVT->m_wSubWord,
               m_pVT->m_fCharSpace, m_pVT->m_nHorzScale, fFontSize,
               pWord->fWordTail, 0);
         }
         if (!bOpened) {
           if (IsOpenStylePunctuation(pWord->Word)) {
             bOpened = TRUE;
             bFullWord = TRUE;
           } else if (pOldWord) {
@@ skipping 35 matching lines @@
           line.nBeginWordIndex = nLineHead;
           line.nEndWordIndex = nLineTail;
           line.nTotalWord = nLineTail - nLineHead + 1;
           line.fLineWidth = fLineWidth;
           line.fLineAscent = fLineAscent;
           line.fLineDescent = fLineDescent;
           m_pSection->AddLine(line);
         }
         fMaxY += (fLineAscent + m_pVT->GetLineLeading(m_pSection->m_SecInfo));
         fMaxY += (-fLineDescent);
-        fMaxX = FPDF_MAX(fLineWidth, fMaxX);
+        fMaxX = std::max(fLineWidth, fMaxX);
         nLineHead = i;
         fLineWidth = 0.0f;
         fLineAscent = 0.0f;
         fLineDescent = 0.0f;
         nCharIndex = 0;
         nLineFullWordIndex = 0;
         bFullWord = FALSE;
       } else {
         fLineWidth += fWordWidth;
         i++;
       }
     }
     if (nLineHead <= nTotalWords - 1) {
       nLineTail = nTotalWords - 1;
       if (bTypeset) {
         line.nBeginWordIndex = nLineHead;
         line.nEndWordIndex = nLineTail;
         line.nTotalWord = nLineTail - nLineHead + 1;
         line.fLineWidth = fLineWidth;
         line.fLineAscent = fLineAscent;
         line.fLineDescent = fLineDescent;
         m_pSection->AddLine(line);
       }
       fMaxY += (fLineAscent + m_pVT->GetLineLeading(m_pSection->m_SecInfo));
       fMaxY += (-fLineDescent);
-      fMaxX = FPDF_MAX(fLineWidth, fMaxX);
+      fMaxX = std::max(fLineWidth, fMaxX);
     }
   } else {
     if (bTypeset) {
       fLineAscent = m_pVT->GetLineAscent(m_pSection->m_SecInfo);
       fLineDescent = m_pVT->GetLineDescent(m_pSection->m_SecInfo);
     } else {
       fLineAscent =
           m_pVT->GetFontAscent(m_pVT->GetDefaultFontIndex(), fFontSize);
       fLineDescent =
           m_pVT->GetFontDescent(m_pVT->GetDefaultFontIndex(), fFontSize);
@@ skipping 11 matching lines @@
               (-fLineDescent));
   }
   m_rcRet = CPVT_FloatRect(0, 0, fMaxX, fMaxY);
 }
 void CTypeset::OutputLines() {
   ASSERT(m_pVT);
   ASSERT(m_pSection);
   FX_FLOAT fMinX = 0.0f, fMinY = 0.0f, fMaxX = 0.0f, fMaxY = 0.0f;
   FX_FLOAT fPosX = 0.0f, fPosY = 0.0f;
   FX_FLOAT fLineIndent = m_pVT->GetLineIndent(m_pSection->m_SecInfo);
-  FX_FLOAT fTypesetWidth = FPDF_MAX(m_pVT->GetPlateWidth() - fLineIndent, 0.0f);
+  FX_FLOAT fTypesetWidth = std::max(m_pVT->GetPlateWidth() - fLineIndent, 0.0f);
   switch (m_pVT->GetAlignment(m_pSection->m_SecInfo)) {
     default:
     case 0:
       fMinX = 0.0f;
       break;
     case 1:
       fMinX = (fTypesetWidth - m_rcRet.Width()) * PVT_HALF;
       break;
     case 2:
       fMinX = fTypesetWidth - m_rcRet.Width();
@@ skipping 518 matching lines @@
     delete m_SectionArray.GetAt(s);
   }
   m_SectionArray.RemoveAll();
 }
 CPVT_WordPlace CPDF_VariableText::AddSection(const CPVT_WordPlace& place,
                                              const CPVT_SectionInfo& secinfo) {
   if (IsValid() && !m_bMultiLine) {
     return place;
   }
   int32_t nSecIndex =
-      FPDF_MAX(FPDF_MIN(place.nSecIndex, m_SectionArray.GetSize()), 0);
+      std::max(std::min(place.nSecIndex, m_SectionArray.GetSize()), 0);
   CSection* pSection = new CSection(this);
   pSection->m_SecInfo = secinfo;
   pSection->SecPlace.nSecIndex = nSecIndex;
   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()) {
     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) {
     return place;
   }
   CPVT_WordPlace newplace = place;
   newplace.nSecIndex =
-      FPDF_MAX(FPDF_MIN(newplace.nSecIndex, m_SectionArray.GetSize() - 1), 0);
+      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;
@@ skipping 24 matching lines @@
 }
 FX_BOOL CPDF_VariableText::GetSectionInfo(const CPVT_WordPlace& place,
                                           CPVT_SectionInfo& secinfo) {
   if (CSection* pSection = m_SectionArray.GetAt(place.nSecIndex)) {
     secinfo = pSection->m_SecInfo;
     return TRUE;
   }
   return FALSE;
 }
 CPDF_Rect CPDF_VariableText::GetContentRect() const {
-  return InToOut(CPDF_EditContainer::GetContentRect());
+  return InToOut(CPVT_FloatRect(CPDF_EditContainer::GetContentRect()));
 }
 FX_FLOAT CPDF_VariableText::GetWordFontSize(const CPVT_WordInfo& WordInfo,
                                             FX_BOOL bFactFontSize) {
   return m_bRichText && WordInfo.pWordProps
              ? (WordInfo.pWordProps->nScriptType == PVTWORD_SCRIPT_NORMAL ||
                         bFactFontSize
                     ? WordInfo.pWordProps->fFontSize
                     : WordInfo.pWordProps->fFontSize * PVT_HALF)
              : GetFontSize();
 }
@@ skipping 223 matching lines @@
     }
   }
   return (FX_FLOAT)gFontSizeSteps[nMid];
 }
 FX_BOOL CPDF_VariableText::IsBigger(FX_FLOAT fFontSize) {
   FX_BOOL bBigger = FALSE;
   CPVT_Size 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);
-      szTotal.x = FPDF_MAX(size.x, szTotal.x);
+      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 bBigger;
 }
@@ skipping 20 matching lines @@
                        pSection->m_SecInfo.rcSection.top;
           rcSec.top = fPosY;
           rcSec.bottom = fPosY + fOldHeight;
         }
         pSection->m_SecInfo.rcSection = rcSec;
         pSection->ResetLinePlace();
       }
       if (s == 0) {
         rcRet = rcSec;
       } else {
-        rcRet.left = FPDF_MIN(rcSec.left, rcRet.left);
-        rcRet.top = FPDF_MIN(rcSec.top, rcRet.top);
-        rcRet.right = FPDF_MAX(rcSec.right, rcRet.right);
-        rcRet.bottom = FPDF_MAX(rcSec.bottom, rcRet.bottom);
+        rcRet.left = std::min(rcSec.left, rcRet.left);
+        rcRet.top = std::min(rcSec.top, rcRet.top);
+        rcRet.right = std::max(rcSec.right, rcRet.right);
+        rcRet.bottom = std::max(rcSec.bottom, rcRet.bottom);
       }
       fPosY += rcSec.Height();
     }
   }
   return rcRet;
 }
 int32_t CPDF_VariableText::GetCharWidth(int32_t nFontIndex,
                                         FX_WORD Word,
                                         FX_WORD SubWord,
                                         int32_t nWordStyle) {
@@ skipping 180 matching lines @@
     if (pSection->m_SecInfo.pSecProps) {
       *pSection->m_SecInfo.pSecProps = section.SecProps;
     }
     if (pSection->m_SecInfo.pWordProps) {
       *pSection->m_SecInfo.pWordProps = section.WordProps;
     }
     return TRUE;
   }
   return FALSE;
 }