Remove FX_DWORD from core/ and delete definition

core/fxge/win32/fx_win32_print.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 "core/include/fxge/fx_ge.h"
 
 #if _FX_OS_ == _FX_WIN32_DESKTOP_ || _FX_OS_ == _FX_WIN64_DESKTOP_
 
@@ skipping 16 matching lines @@
 int CGdiPrinterDriver::GetDeviceCaps(int caps_id) {
   if (caps_id == FXDC_HORZ_SIZE) {
     return m_HorzSize;
   }
   if (caps_id == FXDC_VERT_SIZE) {
     return m_VertSize;
   }
   return CGdiDeviceDriver::GetDeviceCaps(caps_id);
 }
 FX_BOOL CGdiPrinterDriver::SetDIBits(const CFX_DIBSource* pSource,
-                                     FX_DWORD color,
+                                     uint32_t color,
                                      const FX_RECT* pSrcRect,
                                      int left,
                                      int top,
                                      int blend_type,
                                      int alpha_flag,
                                      void* pIccTransform) {
   if (pSource->IsAlphaMask()) {
     FX_RECT clip_rect(left, top, left + pSrcRect->Width(),
                       top + pSrcRect->Height());
     return StretchDIBits(pSource, color, left - pSrcRect->left,
                          top - pSrcRect->top, pSource->GetWidth(),
                          pSource->GetHeight(), &clip_rect, 0, alpha_flag,
                          pIccTransform, FXDIB_BLEND_NORMAL);
   }
   ASSERT(pSource && !pSource->IsAlphaMask() && pSrcRect);
   ASSERT(blend_type == FXDIB_BLEND_NORMAL);
   if (pSource->HasAlpha()) {
     return FALSE;
   }
   CFX_DIBExtractor temp(pSource);
   CFX_DIBitmap* pBitmap = temp;
   if (!pBitmap) {
     return FALSE;
   }
   return GDI_SetDIBits(pBitmap, pSrcRect, left, top, pIccTransform);
 }
 FX_BOOL CGdiPrinterDriver::StretchDIBits(const CFX_DIBSource* pSource,
-                                         FX_DWORD color,
+                                         uint32_t color,
                                          int dest_left,
                                          int dest_top,
                                          int dest_width,
                                          int dest_height,
                                          const FX_RECT* pClipRect,
-                                         FX_DWORD flags,
+                                         uint32_t flags,
                                          int alpha_flag,
                                          void* pIccTransform,
                                          int blend_type) {
   if (pSource->IsAlphaMask()) {
     int alpha = FXGETFLAG_COLORTYPE(alpha_flag)
                     ? FXGETFLAG_ALPHA_FILL(alpha_flag)
                     : FXARGB_A(color);
     if (pSource->GetBPP() != 1 || alpha != 255 || !m_bSupportROP) {
       return FALSE;
     }
@@ skipping 58 matching lines @@
   ASSERT(pSrc->GetFormat() == FXDIB_1bppRgb ||
          pSrc->GetFormat() == FXDIB_1bppMask ||
          pSrc->GetFormat() == FXDIB_1bppCmyk);
   CFX_DIBExtractor src_bitmap(pSrc);
   CFX_DIBitmap* pSrcBitmap = src_bitmap;
   if (!pSrcBitmap) {
     return NULL;
   }
   int src_width = pSrcBitmap->GetWidth(), src_height = pSrcBitmap->GetHeight();
   uint8_t* src_buf = pSrcBitmap->GetBuffer();
-  FX_DWORD src_pitch = pSrcBitmap->GetPitch();
+  uint32_t src_pitch = pSrcBitmap->GetPitch();
   FX_FLOAT dest_area = pDestMatrix->GetUnitArea();
   FX_FLOAT area_scale = ((FX_FLOAT)(src_width * src_height)) / dest_area;
   FX_FLOAT size_scale = FXSYS_sqrt(area_scale);
   CFX_Matrix adjusted_matrix(*pDestMatrix);
   adjusted_matrix.Scale(size_scale, size_scale);
   CFX_FloatRect result_rect_f = adjusted_matrix.GetUnitRect();
   FX_RECT result_rect = result_rect_f.GetOutterRect();
   CFX_Matrix src2result;
   src2result.e = adjusted_matrix.c + adjusted_matrix.e;
   src2result.f = adjusted_matrix.d + adjusted_matrix.f;
@@ skipping 54 matching lines @@
       }
     }
   }
   if (pSrcBitmap != src_bitmap) {
     delete pSrcBitmap;
   }
   return pTempBitmap;
 }
 FX_BOOL CGdiPrinterDriver::StartDIBits(const CFX_DIBSource* pSource,
                                        int bitmap_alpha,
-                                       FX_DWORD color,
+                                       uint32_t color,
                                        const CFX_Matrix* pMatrix,
-                                       FX_DWORD render_flags,
+                                       uint32_t render_flags,
                                        void*& handle,
                                        int alpha_flag,
                                        void* pIccTransform,
                                        int blend_type) {
   if (bitmap_alpha < 255 || pSource->HasAlpha() ||
       (pSource->IsAlphaMask() && (pSource->GetBPP() != 1 || !m_bSupportROP))) {
     return FALSE;
   }
   CFX_FloatRect unit_rect = pMatrix->GetUnitRect();
   FX_RECT full_rect = unit_rect.GetOutterRect();
@@ skipping 85 matching lines @@
   HRGN hRgn = ::CreateRectRgn(0, 0, 1, 1);
   int ret = ::GetClipRgn(hDC, hRgn);
   if (ret == 1) {
     ret = ::GetRegionData(hRgn, 0, NULL);
     if (ret) {
       RGNDATA* pData = (RGNDATA*)FX_Alloc(uint8_t, ret);
       ret = ::GetRegionData(hRgn, ret, pData);
       if (ret) {
         CFX_PathData path;
         path.AllocPointCount(pData->rdh.nCount * 5);
-        for (FX_DWORD i = 0; i < pData->rdh.nCount; i++) {
+        for (uint32_t i = 0; i < pData->rdh.nCount; i++) {
           RECT* pRect = (RECT*)(pData->Buffer + pData->rdh.nRgnSize * i);
           path.AppendRect((FX_FLOAT)pRect->left, (FX_FLOAT)pRect->bottom,
                           (FX_FLOAT)pRect->right, (FX_FLOAT)pRect->top);
         }
         m_PSRenderer.SetClip_PathFill(&path, NULL, FXFILL_WINDING);
       }
       FX_Free(pData);
     }
   }
   ::DeleteObject(hRgn);
@@ skipping 57 matching lines @@
   }
   return m_PSRenderer.DrawPath(pPathData, pObject2Device, pGraphState,
                                fill_color, stroke_color, fill_mode & 3,
                                alpha_flag, pIccTransform);
 }
 FX_BOOL CPSPrinterDriver::GetClipBox(FX_RECT* pRect) {
   *pRect = m_PSRenderer.GetClipBox();
   return TRUE;
 }
 FX_BOOL CPSPrinterDriver::SetDIBits(const CFX_DIBSource* pBitmap,
-                                    FX_DWORD color,
+                                    uint32_t color,
                                     const FX_RECT* pSrcRect,
                                     int left,
                                     int top,
                                     int blend_type,
                                     int alpha_flag,
                                     void* pIccTransform) {
   if (blend_type != FXDIB_BLEND_NORMAL) {
     return FALSE;
   }
   return m_PSRenderer.SetDIBits(pBitmap, color, left, top, alpha_flag,
                                 pIccTransform);
 }
 FX_BOOL CPSPrinterDriver::StretchDIBits(const CFX_DIBSource* pBitmap,
-                                        FX_DWORD color,
+                                        uint32_t color,
                                         int dest_left,
                                         int dest_top,
                                         int dest_width,
                                         int dest_height,
                                         const FX_RECT* pClipRect,
-                                        FX_DWORD flags,
+                                        uint32_t flags,
                                         int alpha_flag,
                                         void* pIccTransform,
                                         int blend_type) {
   if (blend_type != FXDIB_BLEND_NORMAL) {
     return FALSE;
   }
   return m_PSRenderer.StretchDIBits(pBitmap, color, dest_left, dest_top,
                                     dest_width, dest_height, flags, alpha_flag,
                                     pIccTransform);
 }
 FX_BOOL CPSPrinterDriver::StartDIBits(const CFX_DIBSource* pBitmap,
                                       int bitmap_alpha,
-                                      FX_DWORD color,
+                                      uint32_t color,
                                       const CFX_Matrix* pMatrix,
-                                      FX_DWORD render_flags,
+                                      uint32_t render_flags,
                                       void*& handle,
                                       int alpha_flag,
                                       void* pIccTransform,
                                       int blend_type) {
   if (blend_type != FXDIB_BLEND_NORMAL) {
     return FALSE;
   }
   if (bitmap_alpha < 255) {
     return FALSE;
   }
   handle = NULL;
   return m_PSRenderer.DrawDIBits(pBitmap, color, pMatrix, render_flags,
                                  alpha_flag, pIccTransform);
 }
 FX_BOOL CPSPrinterDriver::DrawDeviceText(int nChars,
                                          const FXTEXT_CHARPOS* pCharPos,
                                          CFX_Font* pFont,
                                          CFX_FontCache* pCache,
                                          const CFX_Matrix* pObject2Device,
                                          FX_FLOAT font_size,
-                                         FX_DWORD color,
+                                         uint32_t color,
                                          int alpha_flag,
                                          void* pIccTransform) {
   return m_PSRenderer.DrawText(nChars, pCharPos, pFont, pCache, pObject2Device,
                                font_size, color, alpha_flag, pIccTransform);
 }
 #endif