Remove FX_DWORD from XFA.

xfa/fgas/layout/fgas_textbreak.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_textbreak.h"
 
 #include <algorithm>
 
@@ skipping 44 matching lines @@
   }
   CFX_TxtCharArray* m_pLineChars;
   CFX_TxtPieceArray* m_pLinePieces;
   int32_t m_iStart;
   int32_t m_iWidth;
   int32_t m_iArabicChars;
 };
 
 class CFX_TxtBreak : public IFX_TxtBreak {
  public:
-  CFX_TxtBreak(FX_DWORD dwPolicies);
+  CFX_TxtBreak(uint32_t dwPolicies);
   ~CFX_TxtBreak();
   virtual void Release() { delete this; }
   virtual void SetLineWidth(FX_FLOAT fLineWidth);
   virtual void SetLinePos(FX_FLOAT fLinePos);
-  virtual FX_DWORD GetLayoutStyles() const { return m_dwLayoutStyles; }
-  virtual void SetLayoutStyles(FX_DWORD dwLayoutStyles);
+  virtual uint32_t GetLayoutStyles() const { return m_dwLayoutStyles; }
+  virtual void SetLayoutStyles(uint32_t dwLayoutStyles);
   virtual void SetFont(IFX_Font* pFont);
   virtual void SetFontSize(FX_FLOAT fFontSize);
   virtual void SetTabWidth(FX_FLOAT fTabWidth, FX_BOOL bEquidistant);
   virtual void SetDefaultChar(FX_WCHAR wch);
   virtual void SetParagraphBreakChar(FX_WCHAR wch);
   virtual void SetLineBreakTolerance(FX_FLOAT fTolerance);
   virtual void SetHorizontalScale(int32_t iScale);
   virtual void SetVerticalScale(int32_t iScale);
   virtual void SetCharRotation(int32_t iCharRotation);
   virtual void SetCharSpace(FX_FLOAT fCharSpace);
   virtual void SetAlignment(int32_t iAlignment);
-  virtual FX_DWORD GetContextCharStyles() const;
-  virtual void SetContextCharStyles(FX_DWORD dwCharStyles);
+  virtual uint32_t GetContextCharStyles() const;
+  virtual void SetContextCharStyles(uint32_t dwCharStyles);
   virtual void SetCombWidth(FX_FLOAT fCombWidth);
   virtual void SetUserData(void* pUserData);
-  virtual FX_DWORD AppendChar(FX_WCHAR wch);
-  virtual FX_DWORD EndBreak(FX_DWORD dwStatus = FX_TXTBREAK_PieceBreak);
+  virtual uint32_t AppendChar(FX_WCHAR wch);
+  virtual uint32_t EndBreak(uint32_t dwStatus = FX_TXTBREAK_PieceBreak);
   virtual int32_t CountBreakChars() const;
   virtual int32_t CountBreakPieces() const;
   virtual const CFX_TxtPiece* GetBreakPiece(int32_t index) const;
   virtual void ClearBreakPieces();
   virtual void Reset();
   virtual int32_t GetDisplayPos(
       const FX_TXTRUN* pTxtRun,
       FXTEXT_CHARPOS* pCharPos,
       FX_BOOL bCharCode = FALSE,
       CFX_WideString* pWSForms = NULL,
       FX_AdjustCharDisplayPos pAdjustPos = NULL) const;
   virtual int32_t GetCharRects(const FX_TXTRUN* pTxtRun,
                                CFX_RectFArray& rtArray,
                                FX_BOOL bCharBBox = FALSE) const;
-  void AppendChar_PageLoad(CFX_Char* pCurChar, FX_DWORD dwProps);
-  FX_DWORD AppendChar_Combination(CFX_Char* pCurChar, int32_t iRotation);
-  FX_DWORD AppendChar_Tab(CFX_Char* pCurChar, int32_t iRotation);
-  FX_DWORD AppendChar_Control(CFX_Char* pCurChar, int32_t iRotation);
-  FX_DWORD AppendChar_Arabic(CFX_Char* pCurChar, int32_t iRotation);
-  FX_DWORD AppendChar_Others(CFX_Char* pCurChar, int32_t iRotation);
+  void AppendChar_PageLoad(CFX_Char* pCurChar, uint32_t dwProps);
+  uint32_t AppendChar_Combination(CFX_Char* pCurChar, int32_t iRotation);
+  uint32_t AppendChar_Tab(CFX_Char* pCurChar, int32_t iRotation);
+  uint32_t AppendChar_Control(CFX_Char* pCurChar, int32_t iRotation);
+  uint32_t AppendChar_Arabic(CFX_Char* pCurChar, int32_t iRotation);
+  uint32_t AppendChar_Others(CFX_Char* pCurChar, int32_t iRotation);
 
  protected:
-  FX_DWORD m_dwPolicies;
+  uint32_t m_dwPolicies;
   FX_BOOL m_bPagination;
   IFX_ArabicChar* m_pArabicChar;
   int32_t m_iLineWidth;
-  FX_DWORD m_dwLayoutStyles;
+  uint32_t m_dwLayoutStyles;
   FX_BOOL m_bVertical;
   FX_BOOL m_bArabicContext;
   FX_BOOL m_bArabicShapes;
   FX_BOOL m_bRTL;
   FX_BOOL m_bSingleLine;
   FX_BOOL m_bCombText;
   int32_t m_iArabicContext;
   int32_t m_iCurArabicContext;
   IFX_Font* m_pFont;
   int32_t m_iFontSize;
   FX_BOOL m_bEquidistant;
   int32_t m_iTabWidth;
   FX_WCHAR m_wDefChar;
   FX_WCHAR m_wParagBreakChar;
   int32_t m_iDefChar;
   int32_t m_iLineRotation;
   int32_t m_iCharRotation;
   int32_t m_iRotation;
   int32_t m_iAlignment;
-  FX_DWORD m_dwContextCharStyles;
+  uint32_t m_dwContextCharStyles;
   int32_t m_iCombWidth;
   void* m_pUserData;
-  FX_DWORD m_dwCharType;
+  uint32_t m_dwCharType;
   FX_BOOL m_bCurRTL;
   int32_t m_iCurAlignment;
   FX_BOOL m_bArabicNumber;
   FX_BOOL m_bArabicComma;
   CFX_TxtLine* m_pTxtLine1;
   CFX_TxtLine* m_pTxtLine2;
   CFX_TxtLine* m_pCurLine;
   int32_t m_iReady;
   int32_t m_iTolerance;
   int32_t m_iHorScale;
   int32_t m_iVerScale;
   int32_t m_iCharSpace;
   void SetBreakStatus();
-  int32_t GetLineRotation(FX_DWORD dwStyles) const;
+  int32_t GetLineRotation(uint32_t dwStyles) const;
   CFX_TxtChar* GetLastChar(int32_t index, FX_BOOL bOmitChar = TRUE) const;
   CFX_TxtLine* GetTxtLine(FX_BOOL bReady) const;
   CFX_TxtPieceArray* GetTxtPieces(FX_BOOL bReady) const;
-  FX_DWORD GetUnifiedCharType(FX_DWORD dwType) const;
+  uint32_t GetUnifiedCharType(uint32_t dwType) const;
   void ResetArabicContext();
   void ResetContextCharStyles();
   void EndBreak_UpdateArabicShapes();
   FX_BOOL EndBreak_SplitLine(CFX_TxtLine* pNextLine,
                              FX_BOOL bAllChars,
-                             FX_DWORD dwStatus);
-  void EndBreak_BidiLine(CFX_TPOArray& tpos, FX_DWORD dwStatus);
+                             uint32_t dwStatus);
+  void EndBreak_BidiLine(CFX_TPOArray& tpos, uint32_t dwStatus);
   void EndBreak_Alignment(CFX_TPOArray& tpos,
                           FX_BOOL bAllChars,
-                          FX_DWORD dwStatus);
+                          uint32_t dwStatus);
   int32_t GetBreakPos(CFX_TxtCharArray& ca,
                       int32_t& iEndPos,
                       FX_BOOL bAllChars = FALSE,
                       FX_BOOL bOnlyBrk = FALSE);
   void SplitTextLine(CFX_TxtLine* pCurLine,
                      CFX_TxtLine* pNextLine,
                      FX_BOOL bAllChars = FALSE);
 };
 
 }  // namespace
 
 extern const FX_LINEBREAKTYPE gs_FX_LineBreak_PairTable[64][32];
-IFX_TxtBreak* IFX_TxtBreak::Create(FX_DWORD dwPolicies) {
+IFX_TxtBreak* IFX_TxtBreak::Create(uint32_t dwPolicies) {
   return new CFX_TxtBreak(dwPolicies);
 }
-CFX_TxtBreak::CFX_TxtBreak(FX_DWORD dwPolicies)
+CFX_TxtBreak::CFX_TxtBreak(uint32_t dwPolicies)
     : m_dwPolicies(dwPolicies),
       m_pArabicChar(NULL),
       m_iLineWidth(2000000),
       m_dwLayoutStyles(0),
       m_bVertical(FALSE),
       m_bArabicContext(FALSE),
       m_bArabicShapes(FALSE),
       m_bRTL(FALSE),
       m_bSingleLine(FALSE),
       m_bCombText(FALSE),
@@ skipping 48 matching lines @@
   int32_t iLinePos = FXSYS_round(fLinePos * 20000.0f);
   if (iLinePos < 0) {
     iLinePos = 0;
   }
   if (iLinePos > m_iLineWidth) {
     iLinePos = m_iLineWidth;
   }
   m_pCurLine->m_iStart = iLinePos;
   m_pCurLine->m_iWidth += iLinePos;
 }
-void CFX_TxtBreak::SetLayoutStyles(FX_DWORD dwLayoutStyles) {
+void CFX_TxtBreak::SetLayoutStyles(uint32_t dwLayoutStyles) {
   m_dwLayoutStyles = dwLayoutStyles;
   m_bVertical = (m_dwLayoutStyles & FX_TXTLAYOUTSTYLE_VerticalChars) != 0;
   m_bArabicContext = (m_dwLayoutStyles & FX_TXTLAYOUTSTYLE_ArabicContext) != 0;
   m_bArabicShapes = (m_dwLayoutStyles & FX_TXTLAYOUTSTYLE_ArabicShapes) != 0;
   m_bRTL = (m_dwLayoutStyles & FX_TXTLAYOUTSTYLE_RTLReadingOrder) != 0;
   m_bSingleLine = (m_dwLayoutStyles & FX_TXTLAYOUTSTYLE_SingleLine) != 0;
   m_bCombText = (m_dwLayoutStyles & FX_TXTLAYOUTSTYLE_CombText) != 0;
   ResetArabicContext();
   m_iLineRotation = GetLineRotation(m_dwLayoutStyles);
   m_iRotation = m_iLineRotation + m_iCharRotation;
@@ skipping 81 matching lines @@
     m_dwContextCharStyles |= FX_TXTCHARSTYLE_ArabicNumber;
   }
   if (m_bArabicComma) {
     m_dwContextCharStyles |= FX_TXTCHARSTYLE_ArabicComma;
   }
   if ((m_bArabicContext && m_bCurRTL) || (!m_bArabicContext && m_bRTL)) {
     m_dwContextCharStyles |= FX_TXTCHARSTYLE_RTLReadingOrder;
   }
   m_dwContextCharStyles |= (m_iArabicContext << 8);
 }
-FX_DWORD CFX_TxtBreak::GetContextCharStyles() const {
+uint32_t CFX_TxtBreak::GetContextCharStyles() const {
   return m_dwContextCharStyles;
 }
-void CFX_TxtBreak::SetContextCharStyles(FX_DWORD dwCharStyles) {
+void CFX_TxtBreak::SetContextCharStyles(uint32_t dwCharStyles) {
   m_iCurAlignment = dwCharStyles & 0x0F;
   m_bArabicNumber = (dwCharStyles & FX_TXTCHARSTYLE_ArabicNumber) != 0;
   m_bArabicComma = (dwCharStyles & FX_TXTCHARSTYLE_ArabicComma) != 0;
   m_bCurRTL = (dwCharStyles & FX_TXTCHARSTYLE_RTLReadingOrder) != 0;
   m_iCurArabicContext = m_iArabicContext = ((dwCharStyles & 0x0300) >> 8);
   ResetContextCharStyles();
 }
 void CFX_TxtBreak::SetCombWidth(FX_FLOAT fCombWidth) {
   m_iCombWidth = FXSYS_round(fCombWidth * 20000.0f);
 }
@@ skipping 34 matching lines @@
   if (iScale == m_iHorScale) {
     return;
   }
   SetBreakStatus();
   m_iVerScale = iScale;
 }
 void CFX_TxtBreak::SetCharSpace(FX_FLOAT fCharSpace) {
   m_iCharSpace = FXSYS_round(fCharSpace * 20000.0f);
 }
 static const int32_t gs_FX_TxtLineRotations[8] = {0, 3, 1, 0, 2, 1, 3, 2};
-int32_t CFX_TxtBreak::GetLineRotation(FX_DWORD dwStyles) const {
+int32_t CFX_TxtBreak::GetLineRotation(uint32_t dwStyles) const {
   return gs_FX_TxtLineRotations[(dwStyles & 0x0E) >> 1];
 }
 CFX_TxtChar* CFX_TxtBreak::GetLastChar(int32_t index, FX_BOOL bOmitChar) const {
   CFX_TxtCharArray& ca = *m_pCurLine->m_pLineChars;
   int32_t iCount = ca.GetSize();
   if (index < 0 || index >= iCount) {
     return NULL;
   }
   CFX_TxtChar* pTC;
   int32_t iStart = iCount - 1;
@@ skipping 20 matching lines @@
     return NULL;
   }
 }
 CFX_TxtPieceArray* CFX_TxtBreak::GetTxtPieces(FX_BOOL bReady) const {
   CFX_TxtLine* pTxtLine = GetTxtLine(bReady);
   if (pTxtLine == NULL) {
     return NULL;
   }
   return pTxtLine->m_pLinePieces;
 }
-inline FX_DWORD CFX_TxtBreak::GetUnifiedCharType(FX_DWORD dwType) const {
+inline uint32_t CFX_TxtBreak::GetUnifiedCharType(uint32_t dwType) const {
   return dwType >= FX_CHARTYPE_ArabicAlef ? FX_CHARTYPE_Arabic : dwType;
 }
 void CFX_TxtBreak::ResetArabicContext() {
   if (m_bArabicContext) {
     m_bCurRTL = m_iCurArabicContext > 1;
     m_iCurAlignment = m_iCurArabicContext > 1 ? FX_TXTLINEALIGNMENT_Right
                                               : FX_TXTLINEALIGNMENT_Left;
     m_iCurAlignment |= (m_iAlignment & FX_TXTLINEALIGNMENT_HigherMask);
     m_bArabicNumber = m_iArabicContext >= 1 && m_bArabicShapes;
   } else {
     if (m_bPagination) {
       m_bCurRTL = FALSE;
       m_iCurAlignment = 0;
     } else {
       m_bCurRTL = m_bRTL;
       m_iCurAlignment = m_iAlignment;
     }
     if (m_bRTL) {
       m_bArabicNumber = m_iArabicContext >= 1;
     } else {
       m_bArabicNumber = m_iArabicContext > 1;
     }
     m_bArabicNumber = m_bArabicNumber && m_bArabicShapes;
   }
   m_bArabicComma = m_bArabicNumber;
   ResetContextCharStyles();
 }
-void CFX_TxtBreak::AppendChar_PageLoad(CFX_Char* pCurChar, FX_DWORD dwProps) {
+void CFX_TxtBreak::AppendChar_PageLoad(CFX_Char* pCurChar, uint32_t dwProps) {
   if (!m_bPagination) {
     ((CFX_TxtChar*)pCurChar)->m_dwStatus = 0;
     ((CFX_TxtChar*)pCurChar)->m_pUserData = m_pUserData;
   }
   if (m_bArabicContext || m_bArabicShapes) {
     int32_t iBidiCls = (dwProps & FX_BIDICLASSBITSMASK) >> FX_BIDICLASSBITS;
     int32_t iArabicContext =
         (iBidiCls == FX_BIDICLASS_R || iBidiCls == FX_BIDICLASS_AL)
             ? 2
             : ((iBidiCls == FX_BIDICLASS_L || iBidiCls == FX_BIDICLASS_S) ? 0
                                                                           : 1);
     if (iArabicContext != m_iArabicContext && iArabicContext != 1) {
       m_iArabicContext = iArabicContext;
       if (m_iCurArabicContext == 1) {
         m_iCurArabicContext = iArabicContext;
       }
       ResetArabicContext();
       if (!m_bPagination) {
         CFX_TxtChar* pLastChar = (CFX_TxtChar*)GetLastChar(1, FALSE);
         if (pLastChar != NULL && pLastChar->m_dwStatus < 1) {
           pLastChar->m_dwStatus = FX_TXTBREAK_PieceBreak;
         }
       }
     }
   }
   pCurChar->m_dwCharStyles = m_dwContextCharStyles;
 }
-FX_DWORD CFX_TxtBreak::AppendChar_Combination(CFX_Char* pCurChar,
+uint32_t CFX_TxtBreak::AppendChar_Combination(CFX_Char* pCurChar,
                                               int32_t iRotation) {
   FXSYS_assert(pCurChar != NULL);
   FX_WCHAR wch = pCurChar->m_wCharCode;
   FX_WCHAR wForm;
   int32_t iCharWidth = 0;
   CFX_Char* pLastChar;
   pCurChar->m_iCharWidth = -1;
   if (m_bCombText) {
     iCharWidth = m_iCombWidth;
   } else {
@@ skipping 31 matching lines @@
       if (!m_pFont->GetCharWidth(wForm, iCharWidth, FALSE)) {
         iCharWidth = 0;
       }
     }
     iCharWidth *= m_iFontSize;
     iCharWidth = iCharWidth * m_iHorScale / 100;
   }
   pCurChar->m_iCharWidth = -iCharWidth;
   return FX_TXTBREAK_None;
 }
-FX_DWORD CFX_TxtBreak::AppendChar_Tab(CFX_Char* pCurChar, int32_t iRotation) {
+uint32_t CFX_TxtBreak::AppendChar_Tab(CFX_Char* pCurChar, int32_t iRotation) {
   m_dwCharType = FX_CHARTYPE_Tab;
   if ((m_dwLayoutStyles & FX_TXTLAYOUTSTYLE_ExpandTab) == 0) {
     return FX_TXTBREAK_None;
   }
   int32_t& iLineWidth = m_pCurLine->m_iWidth;
   int32_t iCharWidth;
   if (m_bCombText) {
     iCharWidth = m_iCombWidth;
   } else {
     if (m_bEquidistant) {
       iCharWidth = iLineWidth;
       iCharWidth = m_iTabWidth * (iCharWidth / m_iTabWidth + 1) - iCharWidth;
       if (iCharWidth < FX_TXTBREAK_MinimumTabWidth) {
         iCharWidth += m_iTabWidth;
       }
     } else {
       iCharWidth = m_iTabWidth;
     }
   }
   pCurChar->m_iCharWidth = iCharWidth;
   iLineWidth += iCharWidth;
   if (!m_bSingleLine && iLineWidth >= m_iLineWidth + m_iTolerance) {
     return EndBreak(FX_TXTBREAK_LineBreak);
   }
   return FX_TXTBREAK_None;
 }
-FX_DWORD CFX_TxtBreak::AppendChar_Control(CFX_Char* pCurChar,
+uint32_t CFX_TxtBreak::AppendChar_Control(CFX_Char* pCurChar,
                                           int32_t iRotation) {
   m_dwCharType = FX_CHARTYPE_Control;
-  FX_DWORD dwRet = FX_TXTBREAK_None;
+  uint32_t dwRet = FX_TXTBREAK_None;
   if (!m_bSingleLine) {
     FX_WCHAR wch = pCurChar->m_wCharCode;
     switch (wch) {
       case L'\v':
       case 0x2028:
         dwRet = FX_TXTBREAK_LineBreak;
         break;
       case L'\f':
         dwRet = FX_TXTBREAK_PageBreak;
         break;
       case 0x2029:
         dwRet = FX_TXTBREAK_ParagraphBreak;
         break;
       default:
         if (wch == m_wParagBreakChar) {
           dwRet = FX_TXTBREAK_ParagraphBreak;
         }
         break;
     }
     if (dwRet != FX_TXTBREAK_None) {
       dwRet = EndBreak(dwRet);
     }
   }
   return dwRet;
 }
-FX_DWORD CFX_TxtBreak::AppendChar_Arabic(CFX_Char* pCurChar,
+uint32_t CFX_TxtBreak::AppendChar_Arabic(CFX_Char* pCurChar,
                                          int32_t iRotation) {
-  FX_DWORD dwType = (pCurChar->m_dwCharProps & FX_CHARTYPEBITSMASK);
+  uint32_t dwType = (pCurChar->m_dwCharProps & FX_CHARTYPEBITSMASK);
   int32_t& iLineWidth = m_pCurLine->m_iWidth;
   FX_WCHAR wForm;
   int32_t iCharWidth = 0;
   CFX_Char* pLastChar = NULL;
   FX_BOOL bAlef = FALSE;
   if (!m_bCombText && m_dwCharType >= FX_CHARTYPE_ArabicAlef &&
       m_dwCharType <= FX_CHARTYPE_ArabicDistortion) {
     pLastChar = GetLastChar(1);
     if (pLastChar != NULL) {
       iCharWidth = pLastChar->m_iCharWidth;
@@ skipping 40 matching lines @@
     iCharWidth = iCharWidth * m_iHorScale / 100;
   }
   pCurChar->m_iCharWidth = iCharWidth;
   iLineWidth += iCharWidth;
   m_pCurLine->m_iArabicChars++;
   if (!m_bSingleLine && iLineWidth > m_iLineWidth + m_iTolerance) {
     return EndBreak(FX_TXTBREAK_LineBreak);
   }
   return FX_TXTBREAK_None;
 }
-FX_DWORD CFX_TxtBreak::AppendChar_Others(CFX_Char* pCurChar,
+uint32_t CFX_TxtBreak::AppendChar_Others(CFX_Char* pCurChar,
                                          int32_t iRotation) {
-  FX_DWORD dwProps = pCurChar->m_dwCharProps;
-  FX_DWORD dwType = (dwProps & FX_CHARTYPEBITSMASK);
+  uint32_t dwProps = pCurChar->m_dwCharProps;
+  uint32_t dwType = (dwProps & FX_CHARTYPEBITSMASK);
   int32_t& iLineWidth = m_pCurLine->m_iWidth;
   int32_t iCharWidth = 0;
   m_dwCharType = dwType;
   FX_WCHAR wch = pCurChar->m_wCharCode;
   FX_WCHAR wForm = wch;
   if (dwType == FX_CHARTYPE_Numeric) {
     if (m_bArabicNumber) {
       wForm = wch + 0x0630;
       pCurChar->m_dwCharStyles |= FX_TXTCHARSTYLE_ArabicIndic;
     }
@@ skipping 19 matching lines @@
   iCharWidth += m_iCharSpace;
   pCurChar->m_iCharWidth = iCharWidth;
   iLineWidth += iCharWidth;
   FX_BOOL bBreak = (dwType != FX_CHARTYPE_Space ||
                     (m_dwPolicies & FX_TXTBREAKPOLICY_SpaceBreak) != 0);
   if (!m_bSingleLine && bBreak && iLineWidth > m_iLineWidth + m_iTolerance) {
     return EndBreak(FX_TXTBREAK_LineBreak);
   }
   return FX_TXTBREAK_None;
 }
-typedef FX_DWORD (CFX_TxtBreak::*FX_TxtBreak_LPFAppendChar)(CFX_Char* pCurChar,
+typedef uint32_t (CFX_TxtBreak::*FX_TxtBreak_LPFAppendChar)(CFX_Char* pCurChar,
                                                             int32_t iRotation);
 static const FX_TxtBreak_LPFAppendChar g_FX_TxtBreak_lpfAppendChar[16] = {
     &CFX_TxtBreak::AppendChar_Others,      &CFX_TxtBreak::AppendChar_Tab,
     &CFX_TxtBreak::AppendChar_Others,      &CFX_TxtBreak::AppendChar_Control,
     &CFX_TxtBreak::AppendChar_Combination, &CFX_TxtBreak::AppendChar_Others,
     &CFX_TxtBreak::AppendChar_Others,      &CFX_TxtBreak::AppendChar_Arabic,
     &CFX_TxtBreak::AppendChar_Arabic,      &CFX_TxtBreak::AppendChar_Arabic,
     &CFX_TxtBreak::AppendChar_Arabic,      &CFX_TxtBreak::AppendChar_Arabic,
     &CFX_TxtBreak::AppendChar_Arabic,      &CFX_TxtBreak::AppendChar_Others,
     &CFX_TxtBreak::AppendChar_Others,      &CFX_TxtBreak::AppendChar_Others,
 };
-FX_DWORD CFX_TxtBreak::AppendChar(FX_WCHAR wch) {
-  FX_DWORD dwProps = kTextLayoutCodeProperties[(uint16_t)wch];
-  FX_DWORD dwType = (dwProps & FX_CHARTYPEBITSMASK);
+uint32_t CFX_TxtBreak::AppendChar(FX_WCHAR wch) {
+  uint32_t dwProps = kTextLayoutCodeProperties[(uint16_t)wch];
+  uint32_t dwType = (dwProps & FX_CHARTYPEBITSMASK);
   CFX_TxtChar* pCurChar = m_pCurLine->m_pLineChars->AddSpace();
   pCurChar->m_wCharCode = (uint16_t)wch;
   pCurChar->m_nRotation = m_iCharRotation;
   pCurChar->m_dwCharProps = dwProps;
   pCurChar->m_dwCharStyles = 0;
   pCurChar->m_iCharWidth = 0;
   pCurChar->m_iHorizontalScale = m_iHorScale;
   pCurChar->m_iVertialScale = m_iVerScale;
   pCurChar->m_dwStatus = 0;
   pCurChar->m_iBidiClass = 0;
   pCurChar->m_iBidiLevel = 0;
   pCurChar->m_iBidiPos = 0;
   pCurChar->m_iBidiOrder = 0;
   pCurChar->m_pUserData = NULL;
   AppendChar_PageLoad(pCurChar, dwProps);
-  FX_DWORD dwRet1 = FX_TXTBREAK_None;
+  uint32_t dwRet1 = FX_TXTBREAK_None;
   if (dwType != FX_CHARTYPE_Combination &&
       GetUnifiedCharType(m_dwCharType) != GetUnifiedCharType(dwType)) {
     if (m_dwCharType > 0 &&
         m_pCurLine->m_iWidth > m_iLineWidth + m_iTolerance && !m_bSingleLine) {
       if (m_dwCharType != FX_CHARTYPE_Space || dwType != FX_CHARTYPE_Control) {
         dwRet1 = EndBreak(FX_TXTBREAK_LineBreak);
         int32_t iCount = m_pCurLine->CountChars();
         if (iCount > 0) {
           pCurChar = m_pCurLine->m_pLineChars->GetDataPtr(iCount - 1);
         }
       }
     }
   }
   int32_t iRotation = m_iRotation;
   if (m_bVertical && (dwProps & 0x8000) != 0) {
     iRotation = (iRotation + 1) % 4;
   }
-  FX_DWORD dwRet2 =
+  uint32_t dwRet2 =
       (this->*g_FX_TxtBreak_lpfAppendChar[dwType >> FX_CHARTYPEBITS])(
           pCurChar, iRotation);
   return std::max(dwRet1, dwRet2);
 }
 void CFX_TxtBreak::EndBreak_UpdateArabicShapes() {
   FXSYS_assert(m_bArabicShapes);
   int32_t iCount = m_pCurLine->CountChars();
   if (iCount < 2) {
     return;
   }
@@ skipping 37 matching lines @@
         pCur->m_iCharWidth = iCharWidth;
         iLineWidth += iCharWidth;
       }
     }
     bPrevNum = (pCur->m_dwCharStyles & FX_TXTCHARSTYLE_ArabicIndic) != 0;
     pCur = pNext;
   } while (i < iCount);
 }
 FX_BOOL CFX_TxtBreak::EndBreak_SplitLine(CFX_TxtLine* pNextLine,
                                          FX_BOOL bAllChars,
-                                         FX_DWORD dwStatus) {
+                                         uint32_t dwStatus) {
   int32_t iCount = m_pCurLine->CountChars();
   FX_BOOL bDone = FALSE;
   CFX_Char* pTC;
   if (!m_bSingleLine && m_pCurLine->m_iWidth > m_iLineWidth + m_iTolerance) {
     pTC = m_pCurLine->GetCharPtr(iCount - 1);
     switch (pTC->GetCharType()) {
       case FX_CHARTYPE_Tab:
       case FX_CHARTYPE_Control:
         break;
       case FX_CHARTYPE_Space:
@@ skipping 27 matching lines @@
     m_pCurLine = pNextLine;
     m_dwCharType = 0;
     return TRUE;
   }
   if (bAllChars && !bDone) {
     int32_t iEndPos = m_pCurLine->m_iWidth;
     GetBreakPos(*m_pCurLine->m_pLineChars, iEndPos, bAllChars, TRUE);
   }
   return FALSE;
 }
-void CFX_TxtBreak::EndBreak_BidiLine(CFX_TPOArray& tpos, FX_DWORD dwStatus) {
+void CFX_TxtBreak::EndBreak_BidiLine(CFX_TPOArray& tpos, uint32_t dwStatus) {
   CFX_TxtPiece tp;
   FX_TPO tpo;
   CFX_TxtChar* pTC;
   int32_t i, j;
   CFX_TxtCharArray& chars = *m_pCurLine->m_pLineChars;
   int32_t iCount = m_pCurLine->CountChars();
   FX_BOOL bDone = (m_pCurLine->m_iArabicChars > 0 || m_bCurRTL);
   if (!m_bPagination && bDone) {
     int32_t iBidiNum = 0;
     for (i = 0; i < iCount; i++) {
@@ skipping 89 matching lines @@
     tp.m_iHorizontalScale = pTC->m_iHorizontalScale;
     tp.m_iVerticalScale = pTC->m_iVertialScale;
     pCurPieces->Add(tp);
     tpo.index = 0;
     tpo.pos = 0;
     tpos.Add(tpo);
   }
 }
 void CFX_TxtBreak::EndBreak_Alignment(CFX_TPOArray& tpos,
                                       FX_BOOL bAllChars,
-                                      FX_DWORD dwStatus) {
+                                      uint32_t dwStatus) {
   int32_t iNetWidth = m_pCurLine->m_iWidth, iGapChars = 0, iCharWidth;
   CFX_TxtPieceArray* pCurPieces = m_pCurLine->m_pLinePieces;
   int32_t i, j, iCount = pCurPieces->GetSize();
   FX_BOOL bFind = FALSE;
   FX_TPO tpo;
   CFX_TxtChar* pTC;
-  FX_DWORD dwCharType;
+  uint32_t dwCharType;
   for (i = iCount - 1; i > -1; i--) {
     tpo = tpos.GetAt(i);
     CFX_TxtPiece& ttp = pCurPieces->GetAt(tpo.index);
     if (!bFind) {
       iNetWidth = ttp.GetEndPos();
     }
     FX_BOOL bArabic = FX_IsOdd(ttp.m_iBidiLevel);
     j = bArabic ? 0 : ttp.m_iChars - 1;
     while (j > -1 && j < ttp.m_iChars) {
       pTC = ttp.GetCharPtr(j);
@@ skipping 60 matching lines @@
       iOffset /= 2;
     }
     if (iOffset > 0) {
       for (i = 0; i < iCount; i++) {
         CFX_TxtPiece& ttp = pCurPieces->GetAt(i);
         ttp.m_iStartPos += iOffset;
       }
     }
   }
 }
-FX_DWORD CFX_TxtBreak::EndBreak(FX_DWORD dwStatus) {
+uint32_t CFX_TxtBreak::EndBreak(uint32_t dwStatus) {
   FXSYS_assert(dwStatus >= FX_TXTBREAK_PieceBreak &&
                dwStatus <= FX_TXTBREAK_PageBreak);
   CFX_TxtPieceArray* pCurPieces = m_pCurLine->m_pLinePieces;
   int32_t iCount = pCurPieces->GetSize();
   if (iCount > 0) {
     CFX_TxtPiece* pLastPiece = pCurPieces->GetPtrAt(--iCount);
     if (dwStatus > FX_TXTBREAK_PieceBreak) {
       pLastPiece->m_dwStatus = dwStatus;
     } else {
       dwStatus = pLastPiece->m_dwStatus;
@@ skipping 66 matching lines @@
   if (m_bSingleLine || iEndPos <= m_iLineWidth) {
     if (!bAllChars) {
       return iLength;
     }
     iBreak = iLength;
     iBreakPos = iEndPos;
   }
   FX_BOOL bSpaceBreak = (m_dwPolicies & FX_TXTBREAKPOLICY_SpaceBreak) != 0;
   FX_BOOL bNumberBreak = (m_dwPolicies & FX_TXTBREAKPOLICY_NumberBreak) != 0;
   FX_LINEBREAKTYPE eType;
-  FX_DWORD nCodeProp, nCur, nNext;
+  uint32_t nCodeProp, nCur, nNext;
   CFX_Char* pCur = ca.GetDataPtr(iLength--);
   if (bAllChars) {
     pCur->m_nBreakType = FX_LBT_UNKNOWN;
   }
   nCodeProp = pCur->m_dwCharProps;
   nNext = nCodeProp & 0x003F;
   int32_t iCharWidth = pCur->m_iCharWidth;
   if (iCharWidth > 0) {
     iEndPos -= iCharWidth;
   }
@@ skipping 164 matching lines @@
                                     FX_AdjustCharDisplayPos pAdjustPos) const {
   if (pTxtRun == NULL || pTxtRun->iLength < 1) {
     return 0;
   }
   IFX_TxtAccess* pAccess = pTxtRun->pAccess;
   void* pIdentity = pTxtRun->pIdentity;
   const FX_WCHAR* pStr = pTxtRun->pStr;
   int32_t* pWidths = pTxtRun->pWidths;
   int32_t iLength = pTxtRun->iLength - 1;
   IFX_Font* pFont = pTxtRun->pFont;
-  FX_DWORD dwStyles = pTxtRun->dwStyles;
+  uint32_t dwStyles = pTxtRun->dwStyles;
   CFX_RectF rtText(*pTxtRun->pRect);
   FX_BOOL bRTLPiece =
       (pTxtRun->dwCharStyles & FX_TXTCHARSTYLE_OddBidiLevel) != 0;
   FX_BOOL bArabicNumber =
       (pTxtRun->dwCharStyles & FX_TXTCHARSTYLE_ArabicNumber) != 0;
   FX_BOOL bArabicComma =
       (pTxtRun->dwCharStyles & FX_TXTCHARSTYLE_ArabicComma) != 0;
   FX_FLOAT fFontSize = pTxtRun->fFontSize;
   int32_t iFontSize = FXSYS_round(fFontSize * 20.0f);
   int32_t iAscent = pFont->GetAscent();
   int32_t iDescent = pFont->GetDescent();
   int32_t iMaxHeight = iAscent - iDescent;
   FX_FLOAT fFontHeight = fFontSize;
   FX_FLOAT fAscent = fFontHeight * (FX_FLOAT)iAscent / (FX_FLOAT)iMaxHeight;
   FX_FLOAT fDescent = fFontHeight * (FX_FLOAT)iDescent / (FX_FLOAT)iMaxHeight;
   FX_BOOL bVerticalDoc = (dwStyles & FX_TXTLAYOUTSTYLE_VerticalLayout) != 0;
   FX_BOOL bVerticalChar = (dwStyles & FX_TXTLAYOUTSTYLE_VerticalChars) != 0;
   int32_t iRotation = GetLineRotation(dwStyles) + pTxtRun->iCharRotation;
   int32_t iCharRotation;
   FX_WCHAR wch, wPrev = 0xFEFF, wNext, wForm, wLast = 0xFEFF;
   int32_t iWidth, iCharWidth, iCharHeight;
   FX_FLOAT fX, fY, fCharWidth, fCharHeight;
   int32_t iHorScale = pTxtRun->iHorizontalScale;
   int32_t iVerScale = pTxtRun->iVerticalScale;
   FX_BOOL bSkipSpace = pTxtRun->bSkipSpace;
   FX_BOOL bEmptyChar, bShadda = FALSE, bLam = FALSE;
-  FX_DWORD dwProps, dwCharType;
+  uint32_t dwProps, dwCharType;
   FX_FORMCHAR formChars[3];
   FX_FLOAT fYBase;
   fX = rtText.left;
   if (bVerticalDoc) {
     fX += (rtText.width - fFontSize) / 2.0f;
     fYBase = bRTLPiece ? rtText.bottom() : rtText.top;
     fY = fYBase;
   } else {
     if (bRTLPiece) {
       fX = rtText.right();
@@ skipping 208 matching lines @@
         }
         if (dwCharType == FX_CHARTYPE_Combination) {
           CFX_Rect rtBBox;
           rtBBox.Reset();
           if (pFont->GetCharBBox(wForm, rtBBox, FALSE)) {
             pCharPos->m_OriginY =
                 fYBase + fFontSize -
                 fFontSize * (FX_FLOAT)rtBBox.height / (FX_FLOAT)iMaxHeight;
           }
           if (wForm == wch && wLast != 0xFEFF) {
-            FX_DWORD dwLastProps = FX_GetUnicodeProperties(wLast);
+            uint32_t dwLastProps = FX_GetUnicodeProperties(wLast);
             if ((dwLastProps & FX_CHARTYPEBITSMASK) ==
                 FX_CHARTYPE_Combination) {
               CFX_Rect rtBBox;
               rtBBox.Reset();
               if (pFont->GetCharBBox(wLast, rtBBox, FALSE)) {
                 pCharPos->m_OriginY -= fFontSize * rtBBox.height / iMaxHeight;
               }
             }
           }
         }
@@ skipping 202 matching lines @@
         rtBBoxF.height = fHeight;
         rtBBoxF.top = std::max(rtBBoxF.top, 0.0f);
       }
       rtArray.SetAt(i, rtBBoxF);
       continue;
     }
     rtArray.SetAt(i, rect);
   }
   return iLength;
 }