Remove FX_DWORD from XFA.

xfa/fxfa/app/xfa_ffwidget.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/fxfa/app/xfa_ffwidget.h"
 
 #include <algorithm>
 
@@ skipping 51 matching lines @@
       rtWidget.top = rtWidget.bottom();
       break;
     case 270:
       rtWidget.left = rtWidget.right();
       fValue = rtWidget.width;
       rtWidget.width = rtWidget.height;
       rtWidget.height = fValue;
       break;
   }
 }
-FX_DWORD CXFA_FFWidget::GetStatus() {
+uint32_t CXFA_FFWidget::GetStatus() {
   return m_dwStatus;
 }
 
-void CXFA_FFWidget::ModifyStatus(FX_DWORD dwAdded, FX_DWORD dwRemoved) {
+void CXFA_FFWidget::ModifyStatus(uint32_t dwAdded, uint32_t dwRemoved) {
   m_dwStatus = (m_dwStatus & ~dwRemoved) | dwAdded;
 }
 
 FX_BOOL CXFA_FFWidget::GetBBox(CFX_RectF& rtBox,
-                               FX_DWORD dwStatus,
+                               uint32_t dwStatus,
                                FX_BOOL bDrawFocus) {
   if (bDrawFocus)
     return FALSE;
   if (m_pPageView)
     m_pPageView->GetPageViewRect(rtBox);
   return TRUE;
 }
 
 CXFA_WidgetAcc* CXFA_FFWidget::GetDataAcc() {
   return m_pDataAcc;
 }
 FX_BOOL CXFA_FFWidget::GetToolTip(CFX_WideString& wsToolTip) {
   if (CXFA_Assist assist = m_pDataAcc->GetAssist()) {
     if (CXFA_ToolTip toolTip = assist.GetToolTip()) {
       return toolTip.GetTip(wsToolTip);
     }
   }
   return GetCaptionText(wsToolTip);
 }
 void CXFA_FFWidget::RenderWidget(CFX_Graphics* pGS,
                                  CFX_Matrix* pMatrix,
-                                 FX_DWORD dwStatus,
+                                 uint32_t dwStatus,
                                  int32_t iRotate) {
   if (!IsMatchVisibleStatus(dwStatus)) {
     return;
   }
   CXFA_Border border = m_pDataAcc->GetBorder();
   if (border) {
     CFX_RectF rtBorder;
     GetRectWithoutRotate(rtBorder);
     CXFA_Margin margin = border.GetMargin();
     if (margin) {
@@ skipping 16 matching lines @@
   return TRUE;
 }
 FX_BOOL CXFA_FFWidget::UpdateFWLData() {
   return FALSE;
 }
 void CXFA_FFWidget::UpdateWidgetProperty() {}
 void CXFA_FFWidget::DrawBorder(CFX_Graphics* pGS,
                                CXFA_Box box,
                                const CFX_RectF& rtBorder,
                                CFX_Matrix* pMatrix,
-                               FX_DWORD dwFlags) {
+                               uint32_t dwFlags) {
   XFA_DrawBox(box, pGS, rtBorder, pMatrix, dwFlags);
 }
 void CXFA_FFWidget::InvalidateWidget(const CFX_RectF* pRect) {
   if (!pRect) {
     CFX_RectF rtWidget;
     GetBBox(rtWidget, XFA_WIDGETSTATUS_Focused);
     rtWidget.Inflate(2, 2);
     GetDoc()->GetDocProvider()->InvalidateRect(m_pPageView, rtWidget,
                                                XFA_INVALIDATE_CurrentPage);
   } else {
@@ skipping 21 matching lines @@
 }
 FX_BOOL CXFA_FFWidget::IsFocused() {
   return m_dwStatus & XFA_WIDGETSTATUS_Focused;
 }
 FX_BOOL CXFA_FFWidget::OnMouseEnter() {
   return FALSE;
 }
 FX_BOOL CXFA_FFWidget::OnMouseExit() {
   return FALSE;
 }
-FX_BOOL CXFA_FFWidget::OnLButtonDown(FX_DWORD dwFlags,
+FX_BOOL CXFA_FFWidget::OnLButtonDown(uint32_t dwFlags,
                                      FX_FLOAT fx,
                                      FX_FLOAT fy) {
   return FALSE;
 }
-FX_BOOL CXFA_FFWidget::OnLButtonUp(FX_DWORD dwFlags, FX_FLOAT fx, FX_FLOAT fy) {
+FX_BOOL CXFA_FFWidget::OnLButtonUp(uint32_t dwFlags, FX_FLOAT fx, FX_FLOAT fy) {
   return FALSE;
 }
-FX_BOOL CXFA_FFWidget::OnLButtonDblClk(FX_DWORD dwFlags,
+FX_BOOL CXFA_FFWidget::OnLButtonDblClk(uint32_t dwFlags,
                                        FX_FLOAT fx,
                                        FX_FLOAT fy) {
   return FALSE;
 }
-FX_BOOL CXFA_FFWidget::OnMouseMove(FX_DWORD dwFlags, FX_FLOAT fx, FX_FLOAT fy) {
+FX_BOOL CXFA_FFWidget::OnMouseMove(uint32_t dwFlags, FX_FLOAT fx, FX_FLOAT fy) {
   return FALSE;
 }
-FX_BOOL CXFA_FFWidget::OnMouseWheel(FX_DWORD dwFlags,
+FX_BOOL CXFA_FFWidget::OnMouseWheel(uint32_t dwFlags,
                                     int16_t zDelta,
                                     FX_FLOAT fx,
                                     FX_FLOAT fy) {
   return FALSE;
 }
-FX_BOOL CXFA_FFWidget::OnRButtonDown(FX_DWORD dwFlags,
+FX_BOOL CXFA_FFWidget::OnRButtonDown(uint32_t dwFlags,
                                      FX_FLOAT fx,
                                      FX_FLOAT fy) {
   return FALSE;
 }
-FX_BOOL CXFA_FFWidget::OnRButtonUp(FX_DWORD dwFlags, FX_FLOAT fx, FX_FLOAT fy) {
+FX_BOOL CXFA_FFWidget::OnRButtonUp(uint32_t dwFlags, FX_FLOAT fx, FX_FLOAT fy) {
   return FALSE;
 }
-FX_BOOL CXFA_FFWidget::OnRButtonDblClk(FX_DWORD dwFlags,
+FX_BOOL CXFA_FFWidget::OnRButtonDblClk(uint32_t dwFlags,
                                        FX_FLOAT fx,
                                        FX_FLOAT fy) {
   return FALSE;
 }
 
 FX_BOOL CXFA_FFWidget::OnSetFocus(CXFA_FFWidget* pOldWidget) {
   CXFA_FFWidget* pParent = GetParent();
   if (pParent && !pParent->IsAncestorOf(pOldWidget)) {
     pParent->OnSetFocus(pOldWidget);
   }
   m_dwStatus |= XFA_WIDGETSTATUS_Focused;
   CXFA_EventParam eParam;
   eParam.m_eType = XFA_EVENT_Enter;
   eParam.m_pTarget = m_pDataAcc;
   m_pDataAcc->ProcessEvent(XFA_ATTRIBUTEENUM_Enter, &eParam);
   return TRUE;
 }
 FX_BOOL CXFA_FFWidget::OnKillFocus(CXFA_FFWidget* pNewWidget) {
   m_dwStatus &= ~XFA_WIDGETSTATUS_Focused;
   EventKillFocus();
   if (pNewWidget) {
     CXFA_FFWidget* pParent = GetParent();
     if (pParent && !pParent->IsAncestorOf(pNewWidget)) {
       pParent->OnKillFocus(pNewWidget);
     }
   }
   return TRUE;
 }
-FX_BOOL CXFA_FFWidget::OnKeyDown(FX_DWORD dwKeyCode, FX_DWORD dwFlags) {
+FX_BOOL CXFA_FFWidget::OnKeyDown(uint32_t dwKeyCode, uint32_t dwFlags) {
   return FALSE;
 }
-FX_BOOL CXFA_FFWidget::OnKeyUp(FX_DWORD dwKeyCode, FX_DWORD dwFlags) {
+FX_BOOL CXFA_FFWidget::OnKeyUp(uint32_t dwKeyCode, uint32_t dwFlags) {
   return FALSE;
 }
-FX_BOOL CXFA_FFWidget::OnChar(FX_DWORD dwChar, FX_DWORD dwFlags) {
+FX_BOOL CXFA_FFWidget::OnChar(uint32_t dwChar, uint32_t dwFlags) {
   return FALSE;
 }
-FX_DWORD CXFA_FFWidget::OnHitTest(FX_FLOAT fx, FX_FLOAT fy) {
+uint32_t CXFA_FFWidget::OnHitTest(FX_FLOAT fx, FX_FLOAT fy) {
   return FALSE;
 }
 FX_BOOL CXFA_FFWidget::OnSetCursor(FX_FLOAT fx, FX_FLOAT fy) {
   return FALSE;
 }
 void CXFA_FFWidget::Rotate2Normal(FX_FLOAT& fx, FX_FLOAT& fy) {
   CFX_Matrix mt;
   GetRotateMatrix(mt);
   if (mt.IsIdentity()) {
     return;
@@ skipping 130 matching lines @@
 void CXFA_FFWidget::GetMinMaxHeight(FX_FLOAT fMinHeight, FX_FLOAT fMaxHeight) {
   fMinHeight = fMaxHeight = 0;
   FX_FLOAT fHeight = 0;
   if (m_pDataAcc->GetHeight(fHeight)) {
     fMinHeight = fMaxHeight = fHeight;
   } else {
     m_pDataAcc->GetMinHeight(fMinHeight);
     m_pDataAcc->GetMaxHeight(fMaxHeight);
   }
 }
-FX_BOOL CXFA_FFWidget::IsMatchVisibleStatus(FX_DWORD dwStatus) {
+FX_BOOL CXFA_FFWidget::IsMatchVisibleStatus(uint32_t dwStatus) {
   return m_dwStatus & XFA_WIDGETSTATUS_Visible;
 }
 void CXFA_FFWidget::EventKillFocus() {
   if (m_dwStatus & XFA_WIDGETSTATUS_Access) {
     m_dwStatus &= ~XFA_WIDGETSTATUS_Access;
     return;
   }
   CXFA_EventParam eParam;
   eParam.m_eType = XFA_EVENT_Exit;
   eParam.m_pTarget = m_pDataAcc;
@@ skipping 64 matching lines @@
 }
 class CXFA_ImageRenderer {
  public:
   CXFA_ImageRenderer();
   ~CXFA_ImageRenderer();
   FX_BOOL Start(CFX_RenderDevice* pDevice,
                 CFX_DIBSource* pDIBSource,
                 FX_ARGB bitmap_argb,
                 int bitmap_alpha,
                 const CFX_Matrix* pImage2Device,
-                FX_DWORD flags,
+                uint32_t flags,
                 int blendType = FXDIB_BLEND_NORMAL);
   FX_BOOL Continue(IFX_Pause* pPause);
 
  protected:
   CFX_RenderDevice* m_pDevice;
   int m_Status;
   CFX_Matrix m_ImageMatrix;
   CFX_DIBSource* m_pDIBSource;
   CFX_DIBitmap* m_pCloneConvert;
   int m_BitmapAlpha;
   FX_ARGB m_FillArgb;
-  FX_DWORD m_Flags;
+  uint32_t m_Flags;
   CFX_ImageTransformer* m_pTransformer;
   void* m_DeviceHandle;
   int32_t m_BlendType;
   FX_BOOL m_Result;
   FX_BOOL m_bPrint;
   FX_BOOL StartDIBSource();
   void CompositeDIBitmap(CFX_DIBitmap* pDIBitmap,
                          int left,
                          int top,
                          FX_ARGB mask_argb,
@@ skipping 24 matching lines @@
   }
   if (m_DeviceHandle) {
     m_pDevice->CancelDIBits(m_DeviceHandle);
   }
 }
 FX_BOOL CXFA_ImageRenderer::Start(CFX_RenderDevice* pDevice,
                                   CFX_DIBSource* pDIBSource,
                                   FX_ARGB bitmap_argb,
                                   int bitmap_alpha,
                                   const CFX_Matrix* pImage2Device,
-                                  FX_DWORD flags,
+                                  uint32_t flags,
                                   int blendType) {
   m_pDevice = pDevice;
   m_pDIBSource = pDIBSource;
   m_FillArgb = bitmap_argb;
   m_BitmapAlpha = bitmap_alpha;
   m_ImageMatrix = *pImage2Device;
   m_Flags = flags;
   m_BlendType = blendType;
   return StartDIBSource();
 }
@@ skipping 122 matching lines @@
   FX_BOOL bGroup = Transparency & PDFTRANS_GROUP;
   if (blend_mode == FXDIB_BLEND_NORMAL) {
     if (!pDIBitmap->IsAlphaMask()) {
       if (bitmap_alpha < 255) {
         pDIBitmap->MultiplyAlpha(bitmap_alpha);
       }
       if (m_pDevice->SetDIBits(pDIBitmap, left, top)) {
         return;
       }
     } else {
-      FX_DWORD fill_argb = (mask_argb);
+      uint32_t fill_argb = (mask_argb);
       if (bitmap_alpha < 255) {
         ((uint8_t*)&fill_argb)[3] =
             ((uint8_t*)&fill_argb)[3] * bitmap_alpha / 255;
       }
       if (m_pDevice->SetBitMask(pDIBitmap, left, top, fill_argb)) {
         return;
       }
     }
   }
   FX_BOOL bBackAlphaRequired = blend_mode && bIsolated;
@@ skipping 166 matching lines @@
   if (pStr == NULL) {
     return 0;
   }
   uint8_t* pBuffer =
       XFA_RemoveBase64Whitespace((uint8_t*)pStr, FXSYS_strlen((FX_CHAR*)pStr));
   if (pBuffer == NULL) {
     return 0;
   }
   int32_t iLen = FXSYS_strlen((FX_CHAR*)pBuffer);
   int32_t i = 0, j = 0;
-  FX_DWORD dwLimb = 0;
+  uint32_t dwLimb = 0;
   for (; i + 3 < iLen; i += 4) {
     if (pBuffer[i] == '=' || pBuffer[i + 1] == '=' || pBuffer[i + 2] == '=' ||
         pBuffer[i + 3] == '=') {
       if (pBuffer[i] == '=' || pBuffer[i + 1] == '=') {
         break;
       }
       if (pBuffer[i + 2] == '=') {
-        dwLimb = ((FX_DWORD)g_inv_base64[pBuffer[i]] << 6) |
-                 ((FX_DWORD)g_inv_base64[pBuffer[i + 1]]);
+        dwLimb = ((uint32_t)g_inv_base64[pBuffer[i]] << 6) |
+                 ((uint32_t)g_inv_base64[pBuffer[i + 1]]);
         pOutBuffer[j] = (uint8_t)(dwLimb >> 4) & 0xFF;
         j++;
       } else {
-        dwLimb = ((FX_DWORD)g_inv_base64[pBuffer[i]] << 12) |
-                 ((FX_DWORD)g_inv_base64[pBuffer[i + 1]] << 6) |
-                 ((FX_DWORD)g_inv_base64[pBuffer[i + 2]]);
+        dwLimb = ((uint32_t)g_inv_base64[pBuffer[i]] << 12) |
+                 ((uint32_t)g_inv_base64[pBuffer[i + 1]] << 6) |
+                 ((uint32_t)g_inv_base64[pBuffer[i + 2]]);
         pOutBuffer[j] = (uint8_t)(dwLimb >> 10) & 0xFF;
         pOutBuffer[j + 1] = (uint8_t)(dwLimb >> 2) & 0xFF;
         j += 2;
       }
     } else {
-      dwLimb = ((FX_DWORD)g_inv_base64[pBuffer[i]] << 18) |
-               ((FX_DWORD)g_inv_base64[pBuffer[i + 1]] << 12) |
-               ((FX_DWORD)g_inv_base64[pBuffer[i + 2]] << 6) |
-               ((FX_DWORD)g_inv_base64[pBuffer[i + 3]]);
+      dwLimb = ((uint32_t)g_inv_base64[pBuffer[i]] << 18) |
+               ((uint32_t)g_inv_base64[pBuffer[i + 1]] << 12) |
+               ((uint32_t)g_inv_base64[pBuffer[i + 2]] << 6) |
+               ((uint32_t)g_inv_base64[pBuffer[i + 3]]);
       pOutBuffer[j] = (uint8_t)(dwLimb >> 16) & 0xff;
       pOutBuffer[j + 1] = (uint8_t)(dwLimb >> 8) & 0xff;
       pOutBuffer[j + 2] = (uint8_t)(dwLimb)&0xff;
       j += 3;
     }
   }
   FX_Free(pBuffer);
   return j;
 }
 
 static const FX_CHAR g_base64_chars[] =
     "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 
 FX_CHAR* XFA_Base64Encode(const uint8_t* buf, int32_t buf_len) {
   FX_CHAR* out = NULL;
   int i, j;
-  FX_DWORD limb;
+  uint32_t limb;
   out = FX_Alloc(FX_CHAR, ((buf_len * 8 + 5) / 6) + 5);
   for (i = 0, j = 0, limb = 0; i + 2 < buf_len; i += 3, j += 4) {
-    limb = ((FX_DWORD)buf[i] << 16) | ((FX_DWORD)buf[i + 1] << 8) |
-           ((FX_DWORD)buf[i + 2]);
+    limb = ((uint32_t)buf[i] << 16) | ((uint32_t)buf[i + 1] << 8) |
+           ((uint32_t)buf[i + 2]);
     out[j] = g_base64_chars[(limb >> 18) & 63];
     out[j + 1] = g_base64_chars[(limb >> 12) & 63];
     out[j + 2] = g_base64_chars[(limb >> 6) & 63];
     out[j + 3] = g_base64_chars[(limb)&63];
   }
   switch (buf_len - i) {
     case 0:
       break;
     case 1:
-      limb = ((FX_DWORD)buf[i]);
+      limb = ((uint32_t)buf[i]);
       out[j++] = g_base64_chars[(limb >> 2) & 63];
       out[j++] = g_base64_chars[(limb << 4) & 63];
       out[j++] = '=';
       out[j++] = '=';
       break;
     case 2:
-      limb = ((FX_DWORD)buf[i] << 8) | ((FX_DWORD)buf[i + 1]);
+      limb = ((uint32_t)buf[i] << 8) | ((uint32_t)buf[i + 1]);
       out[j++] = g_base64_chars[(limb >> 10) & 63];
       out[j++] = g_base64_chars[(limb >> 4) & 63];
       out[j++] = g_base64_chars[(limb << 2) & 63];
       out[j++] = '=';
       break;
     default:
       break;
   }
   out[j] = '\0';
   return out;
@@ skipping 167 matching lines @@
   }
   return nullptr;
 }
 FX_BOOL XFA_IsCreateWidget(XFA_ELEMENT iType) {
   return iType == XFA_ELEMENT_Field || iType == XFA_ELEMENT_Draw ||
          iType == XFA_ELEMENT_Subform || iType == XFA_ELEMENT_ExclGroup;
 }
 static void XFA_BOX_GetPath_Arc(CXFA_Box box,
                                 CFX_RectF rtDraw,
                                 CFX_Path& fillPath,
-                                FX_DWORD dwFlags) {
+                                uint32_t dwFlags) {
   FX_FLOAT a, b;
   a = rtDraw.width / 2.0f;
   b = rtDraw.height / 2.0f;
   if (box.IsCircular() || (dwFlags & XFA_DRAWBOX_ForceRound) != 0) {
     a = b = std::min(a, b);
   }
   CFX_PointF center = rtDraw.Center();
   rtDraw.left = center.x - a;
   rtDraw.top = center.y - b;
   rtDraw.width = a + a;
@@ skipping 411 matching lines @@
   CFX_Shading shading(ptStart, ptEnd, FALSE, FALSE, crStart, crEnd);
   CFX_Color cr(&shading);
   pGS->SetFillColor(&cr);
   pGS->FillPath(&fillPath, FXFILL_WINDING, pMatrix);
 }
 static void XFA_BOX_Fill(CXFA_Box box,
                          const CXFA_StrokeArray& strokes,
                          CFX_Graphics* pGS,
                          const CFX_RectF& rtWidget,
                          CFX_Matrix* pMatrix,
-                         FX_DWORD dwFlags) {
+                         uint32_t dwFlags) {
   CXFA_Fill fill = box.GetFill();
   if (!fill || fill.GetPresence() != XFA_ATTRIBUTEENUM_Visible) {
     return;
   }
   pGS->SaveGraphState();
   CFX_Path fillPath;
   fillPath.Create();
   XFA_BOX_GetFillPath(box, strokes, rtWidget, fillPath,
                       (dwFlags & XFA_DRAWBOX_ForceRound) != 0);
   fillPath.Close();
@@ skipping 50 matching lines @@
                             XFA_ATTRIBUTEENUM_Butt);
   CFX_Color fxColor(stroke.GetColor());
   pGS->SetStrokeColor(&fxColor);
   pGS->StrokePath(pPath, pMatrix);
   pGS->RestoreGraphState();
 }
 static void XFA_BOX_StrokeArc(CXFA_Box box,
                               CFX_Graphics* pGS,
                               CFX_RectF rtWidget,
                               CFX_Matrix* pMatrix,
-                              FX_DWORD dwFlags) {
+                              uint32_t dwFlags) {
   CXFA_Edge edge = box.GetEdge(0);
   if (!edge || !edge.IsVisible()) {
     return;
   }
   FX_BOOL bVisible = FALSE;
   FX_FLOAT fThickness = 0;
   int32_t i3DType = box.Get3DStyle(bVisible, fThickness);
   if (i3DType) {
     if (bVisible && fThickness >= 0.001f) {
       dwFlags |= XFA_DRAWBOX_Lowered3D;
@@ skipping 239 matching lines @@
       path.Close();
     }
     XFA_BOX_StrokePath(strokes[7], &path, pGS, pMatrix);
   }
 }
 static void XFA_BOX_Stroke(CXFA_Box box,
                            const CXFA_StrokeArray& strokes,
                            CFX_Graphics* pGS,
                            CFX_RectF rtWidget,
                            CFX_Matrix* pMatrix,
-                           FX_DWORD dwFlags) {
+                           uint32_t dwFlags) {
   if (box.IsArc() || (dwFlags & XFA_DRAWBOX_ForceRound) != 0) {
     XFA_BOX_StrokeArc(box, pGS, rtWidget, pMatrix, dwFlags);
     return;
   }
   bool bVisible = false;
   for (int32_t j = 0; j < 4; j++) {
     if (strokes[j * 2 + 1].IsVisible()) {
       bVisible = true;
       break;
     }
@@ skipping 43 matching lines @@
         }
         break;
     }
   }
   XFA_BOX_Stroke_Rect(box, strokes, pGS, rtWidget, pMatrix);
 }
 void XFA_DrawBox(CXFA_Box box,
                  CFX_Graphics* pGS,
                  const CFX_RectF& rtWidget,
                  CFX_Matrix* pMatrix,
-                 FX_DWORD dwFlags) {
+                 uint32_t dwFlags) {
   if (!box || box.GetPresence() != XFA_ATTRIBUTEENUM_Visible) {
     return;
   }
   int32_t iType = box.GetClassID();
   if (iType != XFA_ELEMENT_Arc && iType != XFA_ELEMENT_Border &&
       iType != XFA_ELEMENT_Rectangle) {
     return;
   }
   CXFA_StrokeArray strokes;
   if (!(dwFlags & XFA_DRAWBOX_ForceRound) && iType != XFA_ELEMENT_Arc) {
     box.GetStrokes(strokes);
   }
   XFA_BOX_Fill(box, strokes, pGS, rtWidget, pMatrix, dwFlags);
   XFA_BOX_Stroke(box, strokes, pGS, rtWidget, pMatrix, dwFlags);
 }