Merge to XFA: War on #defines, part 1.

core/src/fpdfapi/fpdf_render/fpdf_render.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 "render_int.h"
 
 #include "core/include/fpdfapi/fpdf_module.h"
 #include "core/include/fpdfapi/fpdf_render.h"
@@ skipping 294 matching lines @@
   m_pCurObj = pObj;
   if (m_Options.m_pOCContext && pObj->m_ContentMark.NotNull() &&
       !m_Options.m_pOCContext->CheckObjectVisible(pObj)) {
     return FALSE;
   }
 
   ProcessClipPath(pObj->m_ClipPath, pObj2Device);
   if (ProcessTransparency(pObj, pObj2Device))
     return FALSE;
 
-  if (pObj->m_Type == PDFPAGE_IMAGE) {
+  if (pObj->m_Type == CPDF_PageObject::IMAGE) {
     m_pObjectRenderer.reset(IPDF_ObjectRenderer::Create(pObj->m_Type));
     if (!m_pObjectRenderer->Start(this, pObj, pObj2Device, FALSE)) {
       if (!m_pObjectRenderer->m_Result)
         DrawObjWithBackground(pObj, pObj2Device);
       m_pObjectRenderer.reset();
       return FALSE;
     }
     return ContinueSingleObject(pObj, pObj2Device, pPause);
   }
 
   ProcessObjectNoClip(pObj, pObj2Device);
   return FALSE;
 }
 
 IPDF_ObjectRenderer* IPDF_ObjectRenderer::Create(int type) {
-  if (type != PDFPAGE_IMAGE) {
+  if (type != CPDF_PageObject::IMAGE) {
     return NULL;
   }
   return new CPDF_ImageRenderer;
 }
 FX_BOOL CPDF_RenderStatus::GetObjectClippedRect(const CPDF_PageObject* pObj,
                                                 const CFX_Matrix* pObj2Device,
                                                 FX_BOOL bLogical,
                                                 FX_RECT& rect) const {
   rect = pObj->GetBBox(pObj2Device);
   FX_RECT rtClip = m_pDevice->GetClipBox();
@@ skipping 32 matching lines @@
   } else if (m_DitherBits == 4) {
     static FX_ARGB pal[16] = {0,   17,  34,  51,  68,  85,  102, 119,
                               136, 153, 170, 187, 204, 221, 238, 255};
     pBitmap->DitherFS(pal, 16, &rect);
   }
 }
 void CPDF_RenderStatus::ProcessObjectNoClip(const CPDF_PageObject* pObj,
                                             const CFX_Matrix* pObj2Device) {
   FX_BOOL bRet = FALSE;
   switch (pObj->m_Type) {
-    case PDFPAGE_TEXT:
+    case CPDF_PageObject::TEXT:
       bRet = ProcessText((CPDF_TextObject*)pObj, pObj2Device, NULL);
       break;
-    case PDFPAGE_PATH:
+    case CPDF_PageObject::PATH:
       bRet = ProcessPath((CPDF_PathObject*)pObj, pObj2Device);
       break;
-    case PDFPAGE_IMAGE:
+    case CPDF_PageObject::IMAGE:
       bRet = ProcessImage((CPDF_ImageObject*)pObj, pObj2Device);
       break;
-    case PDFPAGE_SHADING:
+    case CPDF_PageObject::SHADING:
       bRet = ProcessShading((CPDF_ShadingObject*)pObj, pObj2Device);
       break;
-    case PDFPAGE_FORM:
+    case CPDF_PageObject::FORM:
       bRet = ProcessForm((CPDF_FormObject*)pObj, pObj2Device);
       break;
   }
   if (!bRet) {
     DrawObjWithBackground(pObj, pObj2Device);
   }
 }
 FX_BOOL CPDF_RenderStatus::DrawObjWithBlend(const CPDF_PageObject* pObj,
                                             const CFX_Matrix* pObj2Device) {
   FX_BOOL bRet = FALSE;
   switch (pObj->m_Type) {
-    case PDFPAGE_PATH:
+    case CPDF_PageObject::PATH:
       bRet = ProcessPath((CPDF_PathObject*)pObj, pObj2Device);
       break;
-    case PDFPAGE_IMAGE:
+    case CPDF_PageObject::IMAGE:
       bRet = ProcessImage((CPDF_ImageObject*)pObj, pObj2Device);
       break;
-    case PDFPAGE_FORM:
+    case CPDF_PageObject::FORM:
       bRet = ProcessForm((CPDF_FormObject*)pObj, pObj2Device);
       break;
+    default:
+      break;
   }
   return bRet;
 }
 void CPDF_RenderStatus::GetScaledMatrix(CFX_Matrix& matrix) const {
   CFX_Matrix dCTM = m_pDevice->GetCTM();
   matrix.a *= FXSYS_fabs(dCTM.a);
   matrix.d *= FXSYS_fabs(dCTM.d);
 }
 void CPDF_RenderStatus::DrawObjWithBackground(const CPDF_PageObject* pObj,
                                               const CFX_Matrix* pObj2Device) {
   FX_RECT rect;
   if (GetObjectClippedRect(pObj, pObj2Device, FALSE, rect)) {
     return;
   }
   int res = 300;
-  if (pObj->m_Type == PDFPAGE_IMAGE &&
+  if (pObj->m_Type == CPDF_PageObject::IMAGE &&
       m_pDevice->GetDeviceCaps(FXDC_DEVICE_CLASS) == FXDC_PRINTER) {
     res = 0;
   }
   CPDF_ScaledRenderBuffer buffer;
   if (!buffer.Initialize(m_pContext, m_pDevice, rect, pObj, &m_Options, res)) {
     return;
   }
   CFX_Matrix matrix = *pObj2Device;
   matrix.Concat(*buffer.GetMatrix());
   GetScaledMatrix(matrix);
   CPDF_Dictionary* pFormResource = NULL;
-  if (pObj->m_Type == PDFPAGE_FORM) {
+  if (pObj->m_Type == CPDF_PageObject::FORM) {
     CPDF_FormObject* pFormObj = (CPDF_FormObject*)pObj;
     if (pFormObj->m_pForm && pFormObj->m_pForm->m_pFormDict) {
       pFormResource = pFormObj->m_pForm->m_pFormDict->GetDict("Resources");
     }
   }
   CPDF_RenderStatus status;
   status.Initialize(m_pContext, buffer.GetDevice(), buffer.GetMatrix(), NULL,
                     NULL, NULL, &m_Options, m_Transparency, m_bDropObjects,
                     pFormResource);
   status.RenderSingleObject(pObj, &matrix);
@@ skipping 263 matching lines @@
                                                const CFX_Matrix* pObj2Device) {
   const CPDF_GeneralStateData* pGeneralState = pPageObj->m_GeneralState;
   int blend_type =
       pGeneralState ? pGeneralState->m_BlendType : FXDIB_BLEND_NORMAL;
   if (blend_type == FXDIB_BLEND_UNSUPPORTED) {
     return TRUE;
   }
   CPDF_Dictionary* pSMaskDict =
       pGeneralState ? ToDictionary(pGeneralState->m_pSoftMask) : NULL;
   if (pSMaskDict) {
-    if (pPageObj->m_Type == PDFPAGE_IMAGE &&
+    if (pPageObj->m_Type == CPDF_PageObject::IMAGE &&
         ((CPDF_ImageObject*)pPageObj)->m_pImage->GetDict()->KeyExist("SMask")) {
       pSMaskDict = NULL;
     }
   }
   CPDF_Dictionary* pFormResource = NULL;
   FX_FLOAT group_alpha = 1.0f;
   int Transparency = m_Transparency;
   FX_BOOL bGroupTransparent = FALSE;
-  if (pPageObj->m_Type == PDFPAGE_FORM) {
+  if (pPageObj->m_Type == CPDF_PageObject::FORM) {
     CPDF_FormObject* pFormObj = (CPDF_FormObject*)pPageObj;
     const CPDF_GeneralStateData* pStateData =
         pFormObj->m_GeneralState.GetObject();
     if (pStateData) {
       group_alpha = pStateData->m_FillAlpha;
     }
     Transparency = pFormObj->m_pForm->m_Transparency;
     bGroupTransparent = !!(Transparency & PDFTRANS_ISOLATED);
     if (pFormObj->m_pForm->m_pFormDict) {
       pFormResource = pFormObj->m_pForm->m_pFormDict->GetDict("Resources");
     }
   }
   FX_BOOL bTextClip = FALSE;
   if (pPageObj->m_ClipPath.NotNull() && pPageObj->m_ClipPath.GetTextCount() &&
       m_pDevice->GetDeviceClass() == FXDC_DISPLAY &&
       !(m_pDevice->GetDeviceCaps(FXDC_RENDER_CAPS) & FXRC_SOFT_CLIP)) {
     bTextClip = TRUE;
   }
   if ((m_Options.m_Flags & RENDER_OVERPRINT) &&
-      pPageObj->m_Type == PDFPAGE_IMAGE && pGeneralState &&
+      pPageObj->m_Type == CPDF_PageObject::IMAGE && pGeneralState &&
       pGeneralState->m_FillOP && pGeneralState->m_StrokeOP) {
     CPDF_Document* pDocument = NULL;
     CPDF_Page* pPage = NULL;
     if (m_pContext->GetPageCache()) {
       pPage = m_pContext->GetPageCache()->GetPage();
       pDocument = pPage->m_pDocument;
     } else {
       pDocument = ((CPDF_ImageObject*)pPageObj)->m_pImage->GetDocument();
     }
     CPDF_Dictionary* pPageResources = pPage ? pPage->m_pPageResources : NULL;
@@ skipping 99 matching lines @@
       bitmap->MultiplyAlpha(pSMaskSource.get());
   }
   if (pTextMask) {
     bitmap->MultiplyAlpha(pTextMask.get());
     pTextMask.reset();
   }
   if (Transparency & PDFTRANS_GROUP && group_alpha != 1.0f) {
     bitmap->MultiplyAlpha((int32_t)(group_alpha * 255));
   }
   Transparency = m_Transparency;
-  if (pPageObj->m_Type == PDFPAGE_FORM) {
+  if (pPageObj->m_Type == CPDF_PageObject::FORM) {
     Transparency |= PDFTRANS_GROUP;
   }
   CompositeDIBitmap(bitmap, rect.left, rect.top, 0, 255, blend_type,
                     Transparency);
   return TRUE;
 }
 
 CFX_DIBitmap* CPDF_RenderStatus::GetBackdrop(const CPDF_PageObject* pObj,
                                              const FX_RECT& rect,
                                              int& left,
@@ skipping 223 matching lines @@
       CPDF_PageObject* pCurObj =
           pLayer->m_pObjectList->GetObjectAt(m_ObjectPos);
       if (pCurObj && pCurObj->m_Left <= m_ClipRect.right &&
           pCurObj->m_Right >= m_ClipRect.left &&
           pCurObj->m_Bottom <= m_ClipRect.top &&
           pCurObj->m_Top >= m_ClipRect.bottom) {
         if (m_pRenderStatus->ContinueSingleObject(pCurObj, &pLayer->m_Matrix,
                                                   pPause)) {
           return;
         }
-        if (pCurObj->m_Type == PDFPAGE_IMAGE &&
+        if (pCurObj->m_Type == CPDF_PageObject::IMAGE &&
             m_pRenderStatus->m_Options.m_Flags & RENDER_LIMITEDIMAGECACHE) {
           m_pContext->GetPageCache()->CacheOptimization(
               m_pRenderStatus->m_Options.m_dwLimitCacheSize);
         }
-        if (pCurObj->m_Type == PDFPAGE_FORM ||
-            pCurObj->m_Type == PDFPAGE_SHADING) {
+        if (pCurObj->m_Type == CPDF_PageObject::FORM ||
+            pCurObj->m_Type == CPDF_PageObject::SHADING) {
           objs_to_go = 0;
         } else {
           objs_to_go--;
         }
       }
       m_ObjectIndex++;
       pLayer->m_pObjectList->GetNextObject(m_ObjectPos);
       if (objs_to_go == 0) {
         if (pPause && pPause->NeedToPauseNow()) {
           return;
@@ skipping 258 matching lines @@
         item.GetParamType() == CPDF_ContentMarkItem::PropertiesDict) {
       CPDF_Dictionary* pOCG =
           ToDictionary(static_cast<CPDF_Object*>(item.GetParam()));
       if (!CheckOCGVisible(pOCG)) {
         return FALSE;
       }
     }
   }
   return TRUE;
 }