Get rid of NULLs in xfa/

xfa/fgas/layout/fgas_rtfbreak.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 "xfa/fgas/layout/fgas_rtfbreak.h"
 
 #include <algorithm>
 
 #include "core/fxcrt/include/fx_arabic.h"
 #include "core/fxcrt/include/fx_arb.h"
 #include "xfa/fgas/layout/fgas_linebreak.h"
 #include "xfa/fgas/layout/fgas_unicode.h"
 
 CFX_RTFBreak::CFX_RTFBreak(uint32_t dwPolicies)
     : m_dwPolicies(dwPolicies),
       m_iBoundaryStart(0),
       m_iBoundaryEnd(2000000),
       m_dwLayoutStyles(0),
       m_bPagination(FALSE),
       m_bVertical(FALSE),
       m_bSingleLine(FALSE),
       m_bCharCode(FALSE),
-      m_pFont(NULL),
+      m_pFont(nullptr),
       m_iFontHeight(240),
       m_iFontSize(240),
       m_iTabWidth(720000),
       m_PositionedTabs(),
       m_bOrphanLine(FALSE),
       m_wDefChar(0xFEFF),
       m_iDefChar(0),
       m_wLineBreakChar(L'\n'),
       m_iHorizontalScale(100),
       m_iVerticalScale(100),
       m_iLineRotation(0),
       m_iCharRotation(0),
       m_iRotation(0),
       m_iCharSpace(0),
       m_bWordSpace(FALSE),
       m_iWordSpace(0),
       m_bRTL(FALSE),
       m_iAlignment(FX_RTFLINEALIGNMENT_Left),
-      m_pUserData(NULL),
+      m_pUserData(nullptr),
       m_eCharType(FX_CHARTYPE_Unknown),
       m_dwIdentity(0),
       m_RTFLine1(),
       m_RTFLine2(),
-      m_pCurLine(NULL),
+      m_pCurLine(nullptr),
       m_iReady(0),
       m_iTolerance(0) {
   m_pCurLine = &m_RTFLine1;
 }
 CFX_RTFBreak::~CFX_RTFBreak() {
   Reset();
   m_PositionedTabs.RemoveAll();
-  if (m_pUserData != NULL) {
+  if (m_pUserData)
     m_pUserData->Release();
-  }
 }
 void CFX_RTFBreak::SetLineBoundary(FX_FLOAT fLineStart, FX_FLOAT fLineEnd) {
   if (fLineStart > fLineEnd)
     return;
   m_iBoundaryStart = FXSYS_round(fLineStart * 20000.0f);
   m_iBoundaryEnd = FXSYS_round(fLineEnd * 20000.0f);
   m_pCurLine->m_iStart = std::min(m_pCurLine->m_iStart, m_iBoundaryEnd);
   m_pCurLine->m_iStart = std::max(m_pCurLine->m_iStart, m_iBoundaryStart);
 }
 void CFX_RTFBreak::SetLineStartPos(FX_FLOAT fLinePos) {
@@ skipping 10 matching lines @@
   m_dwLayoutStyles = dwLayoutStyles;
   m_bPagination = (m_dwLayoutStyles & FX_RTFLAYOUTSTYLE_Pagination) != 0;
   m_bVertical = (m_dwLayoutStyles & FX_RTFLAYOUTSTYLE_VerticalChars) != 0;
   m_bSingleLine = (m_dwLayoutStyles & FX_RTFLAYOUTSTYLE_SingleLine) != 0;
   m_bCharCode = (m_dwLayoutStyles & FX_RTFLAYOUTSTYLE_MBCSCode) != 0;
   m_iLineRotation = GetLineRotation(m_dwLayoutStyles);
   m_iRotation = m_iLineRotation + m_iCharRotation;
   m_iRotation %= 4;
 }
 void CFX_RTFBreak::SetFont(IFGAS_Font* pFont) {
-  if (pFont == NULL) {
+  if (!pFont || m_pFont == pFont)
     return;
-  }
-  if (m_pFont == pFont) {
-    return;
-  }
+
   SetBreakStatus();
   m_pFont = pFont;
   m_iDefChar = 0;
-  if (m_pFont != NULL) {
+  if (m_pFont) {
     m_iFontHeight = m_iFontSize;
     if (m_wDefChar != 0xFEFF) {
       m_pFont->GetCharWidth(m_wDefChar, m_iDefChar, FALSE);
       m_iDefChar *= m_iFontSize;
     }
   }
 }
 void CFX_RTFBreak::SetFontSize(FX_FLOAT fFontSize) {
   int32_t iFontSize = FXSYS_round(fFontSize * 20.0f);
   if (m_iFontSize == iFontSize) {
     return;
   }
   SetBreakStatus();
   m_iFontSize = iFontSize;
   m_iDefChar = 0;
-  if (m_pFont != NULL) {
+  if (m_pFont) {
     m_iFontHeight = m_iFontSize;
     if (m_wDefChar != 0xFEFF) {
       m_pFont->GetCharWidth(m_wDefChar, m_iDefChar, FALSE);
       m_iDefChar *= m_iFontSize;
     }
   }
 }
 void CFX_RTFBreak::SetTabWidth(FX_FLOAT fTabWidth) {
   m_iTabWidth = FXSYS_round(fTabWidth * 20000.0f);
 }
@@ skipping 39 matching lines @@
     m_bOrphanLine = FALSE;
   }
 }
 void CFX_RTFBreak::ClearPositionedTabs() {
   m_PositionedTabs.RemoveAll();
   m_bOrphanLine = FALSE;
 }
 void CFX_RTFBreak::SetDefaultChar(FX_WCHAR wch) {
   m_wDefChar = wch;
   m_iDefChar = 0;
-  if (m_wDefChar != 0xFEFF && m_pFont != NULL) {
+  if (m_wDefChar != 0xFEFF && m_pFont) {
     m_pFont->GetCharWidth(m_wDefChar, m_iDefChar, FALSE);
     if (m_iDefChar < 0) {
       m_iDefChar = 0;
     } else {
       m_iDefChar *= m_iFontSize;
     }
   }
 }
 void CFX_RTFBreak::SetLineBreakChar(FX_WCHAR wch) {
   if (wch != L'\r' && wch != L'\n') {
@@ skipping 51 matching lines @@
 void CFX_RTFBreak::SetAlignment(int32_t iAlignment) {
   ASSERT(iAlignment >= FX_RTFLINEALIGNMENT_Left &&
          iAlignment <= FX_RTFLINEALIGNMENT_Distributed);
   m_iAlignment = iAlignment;
 }
 void CFX_RTFBreak::SetUserData(IFX_Retainable* pUserData) {
   if (m_pUserData == pUserData) {
     return;
   }
   SetBreakStatus();
-  if (m_pUserData != NULL) {
+  if (m_pUserData)
     m_pUserData->Release();
-  }
   m_pUserData = pUserData;
-  if (m_pUserData != NULL) {
+  if (m_pUserData)
     m_pUserData->Retain();
-  }
 }
 static const int32_t gs_FX_RTFLineRotations[8] = {0, 3, 1, 0, 2, 1, 3, 2};
 int32_t CFX_RTFBreak::GetLineRotation(uint32_t dwStyles) const {
   return gs_FX_RTFLineRotations[(dwStyles & 0x0E) >> 1];
 }
 void CFX_RTFBreak::SetBreakStatus() {
   m_dwIdentity++;
   int32_t iCount = m_pCurLine->CountChars();
   if (iCount < 1) {
     return;
   }
   CFX_RTFChar& tc = m_pCurLine->GetChar(iCount - 1);
   if (tc.m_dwStatus == 0) {
     tc.m_dwStatus = FX_RTFBREAK_PieceBreak;
   }
 }
 CFX_RTFChar* CFX_RTFBreak::GetLastChar(int32_t index) const {
   CFX_RTFCharArray& tca = m_pCurLine->m_LineChars;
   int32_t iCount = tca.GetSize();
   if (index < 0 || index >= iCount) {
-    return NULL;
+    return nullptr;
   }
   CFX_RTFChar* pTC;
   int32_t iStart = iCount - 1;
   while (iStart > -1) {
     pTC = tca.GetDataPtr(iStart--);
     if (pTC->m_iCharWidth >= 0 ||
         pTC->GetCharType() != FX_CHARTYPE_Combination) {
       if (--index < 0) {
         return pTC;
       }
     }
   }
-  return NULL;
+  return nullptr;
 }
 CFX_RTFLine* CFX_RTFBreak::GetRTFLine(FX_BOOL bReady) const {
   if (bReady) {
-    if (m_iReady == 1) {
+    if (m_iReady == 1)
       return (CFX_RTFLine*)&m_RTFLine1;
-    } else if (m_iReady == 2) {
+    if (m_iReady == 2)
       return (CFX_RTFLine*)&m_RTFLine2;
-    } else {
-      return NULL;
-    }
+    return nullptr;
   }
-  ASSERT(m_pCurLine != NULL);
+  ASSERT(m_pCurLine);
   return m_pCurLine;
 }
 CFX_RTFPieceArray* CFX_RTFBreak::GetRTFPieces(FX_BOOL bReady) const {
   CFX_RTFLine* pRTFLine = GetRTFLine(bReady);
-  if (pRTFLine == NULL) {
-    return NULL;
-  }
-  return &pRTFLine->m_LinePieces;
+  return pRTFLine ? &pRTFLine->m_LinePieces : nullptr;
 }
 inline FX_CHARTYPE CFX_RTFBreak::GetUnifiedCharType(
     FX_CHARTYPE chartype) const {
   return chartype >= FX_CHARTYPE_ArabicAlef ? FX_CHARTYPE_Arabic : chartype;
 }
 int32_t CFX_RTFBreak::GetLastPositionedTab() const {
   int32_t iCount = m_PositionedTabs.GetSize();
   if (iCount < 1) {
     return m_iBoundaryStart;
   }
@@ skipping 36 matching lines @@
   pCurChar->m_dwCharProps = dwProps;
   pCurChar->m_dwCharStyles = 0;
   pCurChar->m_dwLayoutStyles = 0;
   pCurChar->m_iFontSize = m_iFontSize;
   pCurChar->m_iFontHeight = m_iFontHeight;
   pCurChar->m_iHorizontalScale = m_iHorizontalScale;
   pCurChar->m_iVertialScale = m_iVerticalScale;
   pCurChar->m_nRotation = m_iCharRotation;
   pCurChar->m_iCharWidth = 0;
   pCurChar->m_dwIdentity = m_dwIdentity;
-  if (m_pUserData != NULL) {
+  if (m_pUserData)
     m_pUserData->Retain();
-  }
+
   pCurChar->m_pUserData = m_pUserData;
   uint32_t dwRet1 = FX_RTFBREAK_None;
   if (chartype != FX_CHARTYPE_Combination &&
       GetUnifiedCharType(m_eCharType) != GetUnifiedCharType(chartype)) {
     if (!m_bSingleLine && !m_bOrphanLine &&
         m_eCharType != FX_CHARTYPE_Unknown &&
         m_pCurLine->GetLineEnd() > m_iBoundaryEnd + m_iTolerance) {
       if (m_eCharType != FX_CHARTYPE_Space || chartype != FX_CHARTYPE_Control) {
         dwRet1 = EndBreak(FX_RTFBREAK_LineBreak);
         int32_t iCount = m_pCurLine->CountChars();
         if (iCount > 0) {
           pCurChar = m_pCurLine->m_LineChars.GetDataPtr(iCount - 1);
         }
       }
     }
   }
   int32_t iRotation = m_iRotation;
   if (m_bVertical && (dwProps & 0x8000) != 0) {
     iRotation = (iRotation + 1) % 4;
   }
   uint32_t dwRet2 =
       (this->*g_FX_RTFBreak_lpfAppendChar[chartype >> FX_CHARTYPEBITS])(
           pCurChar, iRotation);
   m_eCharType = chartype;
   return std::max(dwRet1, dwRet2);
 }
 uint32_t CFX_RTFBreak::AppendChar_CharCode(FX_WCHAR wch) {
-  ASSERT(m_pFont != NULL && m_pCurLine != NULL);
+  ASSERT(m_pFont && m_pCurLine);
   ASSERT(m_bCharCode);
   m_pCurLine->m_iMBCSChars++;
   CFX_RTFCharArray& tca = m_pCurLine->m_LineChars;
   CFX_RTFChar* pCurChar = tca.AddSpace();
   pCurChar->m_dwStatus = 0;
   pCurChar->m_wCharCode = wch;
   pCurChar->m_dwCharProps = 0;
   pCurChar->m_dwCharStyles = 0;
   pCurChar->m_dwLayoutStyles = m_dwLayoutStyles;
   pCurChar->m_iFontSize = m_iFontSize;
   pCurChar->m_iFontHeight = m_iFontHeight;
   pCurChar->m_iHorizontalScale = m_iHorizontalScale;
   pCurChar->m_iVertialScale = m_iVerticalScale;
   pCurChar->m_nRotation = m_iCharRotation;
   pCurChar->m_iCharWidth = 0;
   pCurChar->m_dwIdentity = m_dwIdentity;
-  if (m_pUserData != NULL) {
+  if (m_pUserData)
     m_pUserData->Retain();
-  }
+
   pCurChar->m_pUserData = m_pUserData;
   int32_t iCharWidth = 0;
   if (m_bVertical != FX_IsOdd(m_iRotation)) {
     iCharWidth = 1000;
   } else {
     if (!m_pFont->GetCharWidth(wch, iCharWidth, TRUE)) {
       iCharWidth = m_iDefChar;
     }
   }
   iCharWidth *= m_iFontSize;
@@ skipping 15 matching lines @@
     iCharWidth = 1000;
   } else {
     if (!m_pFont->GetCharWidth(pCurChar->m_wCharCode, iCharWidth,
                                m_bCharCode)) {
       iCharWidth = 0;
     }
   }
   iCharWidth *= m_iFontSize;
   iCharWidth = iCharWidth * m_iHorizontalScale / 100;
   CFX_RTFChar* pLastChar = GetLastChar(0);
-  if (pLastChar != NULL && pLastChar->GetCharType() > FX_CHARTYPE_Combination) {
+  if (pLastChar && pLastChar->GetCharType() > FX_CHARTYPE_Combination) {
     iCharWidth = -iCharWidth;
   } else {
     m_eCharType = FX_CHARTYPE_Combination;
   }
   pCurChar->m_iCharWidth = iCharWidth;
   if (iCharWidth > 0) {
     m_pCurLine->m_iWidth += iCharWidth;
   }
   return FX_RTFBREAK_None;
 }
@@ skipping 41 matching lines @@
         break;
     }
     if (dwRet2 != FX_RTFBREAK_None) {
       dwRet2 = EndBreak(dwRet2);
     }
   }
   return dwRet2;
 }
 uint32_t CFX_RTFBreak::AppendChar_Arabic(CFX_RTFChar* pCurChar,
                                          int32_t iRotation) {
-  CFX_RTFChar* pLastChar = NULL;
+  CFX_RTFChar* pLastChar = nullptr;
   int32_t& iLineWidth = m_pCurLine->m_iWidth;
   int32_t iCharWidth = 0;
   FX_WCHAR wForm;
   FX_BOOL bAlef = FALSE;
   if (m_eCharType >= FX_CHARTYPE_ArabicAlef &&
       m_eCharType <= FX_CHARTYPE_ArabicDistortion) {
     pLastChar = GetLastChar(1);
-    if (pLastChar != NULL) {
+    if (pLastChar) {
       iLineWidth -= pLastChar->m_iCharWidth;
       CFX_RTFChar* pPrevChar = GetLastChar(2);
       wForm = pdfium::arabic::GetFormChar(pLastChar, pPrevChar, pCurChar);
       bAlef = (wForm == 0xFEFF &&
                pLastChar->GetCharType() == FX_CHARTYPE_ArabicAlef);
       int32_t iLastRotation = pLastChar->m_nRotation + m_iLineRotation;
       if (m_bVertical && (pLastChar->m_dwCharProps & 0x8000) != 0) {
         iLastRotation++;
       }
       if (m_bVertical != FX_IsOdd(iLastRotation)) {
@@ skipping 83 matching lines @@
   if (iCount > 0) {
     CFX_RTFPiece* pLastPiece = pCurPieces->GetPtrAt(--iCount);
     if (dwStatus > FX_RTFBREAK_PieceBreak) {
       pLastPiece->m_dwStatus = dwStatus;
     } else {
       dwStatus = pLastPiece->m_dwStatus;
     }
     return dwStatus;
   } else {
     CFX_RTFLine* pLastLine = GetRTFLine(TRUE);
-    if (pLastLine != NULL) {
+    if (pLastLine) {
       pCurPieces = &pLastLine->m_LinePieces;
       iCount = pCurPieces->GetSize();
       if (iCount-- > 0) {
         CFX_RTFPiece* pLastPiece = pCurPieces->GetPtrAt(iCount);
         if (dwStatus > FX_RTFBREAK_PieceBreak) {
           pLastPiece->m_dwStatus = dwStatus;
         } else {
           dwStatus = pLastPiece->m_dwStatus;
         }
         return dwStatus;
@@ skipping 425 matching lines @@
   }
   if (iLast > -1) {
     iEndPos = iLastPos;
     return iLast;
   }
   return 0;
 }
 void CFX_RTFBreak::SplitTextLine(CFX_RTFLine* pCurLine,
                                  CFX_RTFLine* pNextLine,
                                  FX_BOOL bAllChars) {
-  ASSERT(pCurLine != NULL && pNextLine != NULL);
+  ASSERT(pCurLine && pNextLine);
   int32_t iCount = pCurLine->CountChars();
   if (iCount < 2) {
     return;
   }
   int32_t iEndPos = pCurLine->GetLineEnd();
   CFX_RTFCharArray& curChars = pCurLine->m_LineChars;
   int32_t iCharPos = GetBreakPos(curChars, iEndPos, bAllChars, FALSE);
   if (iCharPos < 0) {
     iCharPos = 0;
   }
@@ skipping 26 matching lines @@
     }
     if (tc->m_dwLayoutStyles & FX_RTFLAYOUTSTYLE_MBCSCode) {
       pCurLine->m_iMBCSChars--;
       pNextLine->m_iMBCSChars++;
     }
     tc->m_dwStatus = 0;
   }
 }
 int32_t CFX_RTFBreak::CountBreakPieces() const {
   CFX_RTFPieceArray* pRTFPieces = GetRTFPieces(TRUE);
-  if (pRTFPieces == NULL) {
-    return 0;
-  }
-  return pRTFPieces->GetSize();
+  return pRTFPieces ? pRTFPieces->GetSize() : 0;
 }
 const CFX_RTFPiece* CFX_RTFBreak::GetBreakPiece(int32_t index) const {
   CFX_RTFPieceArray* pRTFPieces = GetRTFPieces(TRUE);
-  if (pRTFPieces == NULL) {
-    return NULL;
-  }
-  if (index < 0 || index >= pRTFPieces->GetSize()) {
-    return NULL;
-  }
+  if (!pRTFPieces)
+    return nullptr;
+  if (index < 0 || index >= pRTFPieces->GetSize())
+    return nullptr;
   return pRTFPieces->GetPtrAt(index);
 }
 void CFX_RTFBreak::GetLineRect(CFX_RectF& rect) const {
   rect.top = 0;
   CFX_RTFLine* pRTFLine = GetRTFLine(TRUE);
-  if (pRTFLine == NULL) {
+  if (!pRTFLine) {
     rect.left = ((FX_FLOAT)m_iBoundaryStart) / 20000.0f;
     rect.width = rect.height = 0;
     return;
   }
   rect.left = ((FX_FLOAT)pRTFLine->m_iStart) / 20000.0f;
   rect.width = ((FX_FLOAT)pRTFLine->m_iWidth) / 20000.0f;
   CFX_RTFPieceArray& rtfPieces = pRTFLine->m_LinePieces;
   int32_t iCount = rtfPieces.GetSize();
   if (iCount < 1) {
     rect.width = 0;
     return;
   }
   CFX_RTFPiece* pBreakPiece;
   int32_t iLineHeight = 0, iMax;
   for (int32_t i = 0; i < iCount; i++) {
     pBreakPiece = rtfPieces.GetPtrAt(i);
     int32_t iFontHeight = FXSYS_round(pBreakPiece->m_iFontHeight *
                                       pBreakPiece->m_iVerticalScale / 100.0f);
     iMax = std::max(pBreakPiece->m_iFontSize, iFontHeight);
     if (i == 0) {
       iLineHeight = iMax;
     } else if (iLineHeight < iMax) {
       iLineHeight = iMax;
     }
   }
   rect.height = ((FX_FLOAT)iLineHeight) / 20.0f;
 }
 void CFX_RTFBreak::ClearBreakPieces() {
   CFX_RTFLine* pRTFLine = GetRTFLine(TRUE);
-  if (pRTFLine != NULL) {
+  if (pRTFLine)
     pRTFLine->RemoveAll(TRUE);
-  }
   m_iReady = 0;
 }
 void CFX_RTFBreak::Reset() {
   m_eCharType = FX_CHARTYPE_Unknown;
   m_RTFLine1.RemoveAll(TRUE);
   m_RTFLine2.RemoveAll(TRUE);
 }
 int32_t CFX_RTFBreak::GetDisplayPos(const FX_RTFTEXTOBJ* pText,
                                     FXTEXT_CHARPOS* pCharPos,
                                     FX_BOOL bCharCode,
                                     CFX_WideString* pWSForms,
                                     FX_AdjustCharDisplayPos pAdjustPos) const {
-  if (pText == NULL || pText->iLength < 1) {
+  if (!pText || pText->iLength < 1)
     return 0;
-  }
-  ASSERT(pText->pStr != NULL && pText->pWidths != NULL &&
-         pText->pFont != NULL && pText->pRect != NULL);
+
+  ASSERT(pText->pStr && pText->pWidths && pText->pFont && pText->pRect);
   const FX_WCHAR* pStr = pText->pStr;
   int32_t* pWidths = pText->pWidths;
   int32_t iLength = pText->iLength - 1;
   IFGAS_Font* pFont = pText->pFont;
   uint32_t dwStyles = pText->dwLayoutStyles;
   CFX_RectF rtText(*pText->pRect);
   FX_BOOL bRTLPiece = FX_IsOdd(pText->iBidiLevel);
   FX_FLOAT fFontSize = pText->fFontSize;
   int32_t iFontSize = FXSYS_round(fFontSize * 20.0f);
   int32_t iAscent = pFont->GetAscent();
@@ skipping 50 matching lines @@
       }
       if (!bMBCSCode) {
         bEmptyChar = (dwCharType >= FX_CHARTYPE_Tab &&
                       dwCharType <= FX_CHARTYPE_Control);
       } else {
         bEmptyChar = FALSE;
       }
       if (!bEmptyChar) {
         iCount++;
       }
-      if (pCharPos != NULL) {
+      if (pCharPos) {
         iCharWidth /= iFontSize;
         wForm = wch;
         if (!bMBCSCode) {
           if (dwCharType >= FX_CHARTYPE_ArabicAlef) {
             if (i < iLength) {
               wNext = *pStr;
               if (*pWidths < 0) {
                 if (i + 1 < iLength) {
                   wNext = pStr[1];
                 }
@@ skipping 145 matching lines @@
     }
     if (iWidth > 0) {
       wPrev = wch;
     }
   }
   return iCount;
 }
 int32_t CFX_RTFBreak::GetCharRects(const FX_RTFTEXTOBJ* pText,
                                    CFX_RectFArray& rtArray,
                                    FX_BOOL bCharBBox) const {
-  if (pText == NULL || pText->iLength < 1) {
+  if (!pText || pText->iLength < 1)
     return 0;
-  }
-  ASSERT(pText->pStr != NULL && pText->pWidths != NULL &&
-         pText->pFont != NULL && pText->pRect != NULL);
+
+  ASSERT(pText->pStr && pText->pWidths && pText->pFont && pText->pRect);
   const FX_WCHAR* pStr = pText->pStr;
   int32_t* pWidths = pText->pWidths;
   int32_t iLength = pText->iLength;
   CFX_RectF rect(*pText->pRect);
   FX_BOOL bRTLPiece = FX_IsOdd(pText->iBidiLevel);
   FX_FLOAT fFontSize = pText->fFontSize;
   int32_t iFontSize = FXSYS_round(fFontSize * 20.0f);
   FX_FLOAT fScale = fFontSize / 1000.0f;
   IFGAS_Font* pFont = pText->pFont;
-  if (pFont == NULL) {
+  if (!pFont)
     bCharBBox = FALSE;
-  }
+
   CFX_Rect bbox;
   bbox.Set(0, 0, 0, 0);
   if (bCharBBox) {
     bCharBBox = pFont->GetBBox(bbox);
   }
   FX_FLOAT fLeft = std::max(0.0f, bbox.left * fScale);
   FX_FLOAT fHeight = FXSYS_fabs(bbox.height * fScale);
   rtArray.RemoveAll();
   rtArray.SetSize(iLength);
   uint32_t dwStyles = pText->dwLayoutStyles;
@@ skipping 65 matching lines @@
         rtBBoxF.height = fHeight;
         rtBBoxF.top = std::max(rtBBoxF.top, 0.0f);
       }
       rtArray.SetAt(i, rtBBoxF);
       continue;
     }
     rtArray.SetAt(i, rect);
   }
   return iLength;
 }