Convert XFA_ELEMENT to an enum class

xfa/fxfa/parser/xfa_layout_pagemgr_new.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/parser/xfa_layout_pagemgr_new.h"
 
 #include "xfa/fxfa/app/xfa_ffnotify.h"
 #include "xfa/fxfa/parser/xfa_doclayout.h"
 #include "xfa/fxfa/parser/xfa_document.h"
 #include "xfa/fxfa/parser/xfa_document_datamerger_imp.h"
 #include "xfa/fxfa/parser/xfa_document_layout_imp.h"
 #include "xfa/fxfa/parser/xfa_layout_appadapter.h"
 #include "xfa/fxfa/parser/xfa_layout_itemlayout.h"
 #include "xfa/fxfa/parser/xfa_localemgr.h"
 #include "xfa/fxfa/parser/xfa_object.h"
 #include "xfa/fxfa/parser/xfa_parser.h"
 #include "xfa/fxfa/parser/xfa_parser_imp.h"
 #include "xfa/fxfa/parser/xfa_script.h"
 #include "xfa/fxfa/parser/xfa_script_imp.h"
 #include "xfa/fxfa/parser/xfa_utils.h"
 
 namespace {
 
 class PageSetContainerLayoutItem {
  public:
   static inline CXFA_ContainerLayoutItem* GetFirstChild(
       CXFA_ContainerLayoutItem* pLayoutItem) {
-    if (pLayoutItem->m_pFormNode->GetClassID() != XFA_ELEMENT_PageSet)
+    if (pLayoutItem->m_pFormNode->GetClassID() != XFA_Element::PageSet)
       return nullptr;
 
     CXFA_ContainerLayoutItem* pChildItem =
         static_cast<CXFA_ContainerLayoutItem*>(pLayoutItem->m_pFirstChild);
     while (pChildItem &&
-           pChildItem->m_pFormNode->GetClassID() != XFA_ELEMENT_PageSet) {
+           pChildItem->m_pFormNode->GetClassID() != XFA_Element::PageSet) {
       pChildItem =
           static_cast<CXFA_ContainerLayoutItem*>(pChildItem->m_pNextSibling);
     }
     return pChildItem;
   }
 
   static inline CXFA_ContainerLayoutItem* GetNextSibling(
       CXFA_ContainerLayoutItem* pLayoutItem) {
     CXFA_ContainerLayoutItem* pChildItem =
         static_cast<CXFA_ContainerLayoutItem*>(pLayoutItem->m_pNextSibling);
     while (pChildItem &&
-           pChildItem->m_pFormNode->GetClassID() != XFA_ELEMENT_PageSet) {
+           pChildItem->m_pFormNode->GetClassID() != XFA_Element::PageSet) {
       pChildItem =
           static_cast<CXFA_ContainerLayoutItem*>(pChildItem->m_pNextSibling);
     }
     return pChildItem;
   }
 
   static inline CXFA_ContainerLayoutItem* GetParent(
       CXFA_ContainerLayoutItem* pLayoutItem) {
     return static_cast<CXFA_ContainerLayoutItem*>(pLayoutItem->m_pParent);
   }
@@ skipping 180 matching lines @@
     pNextLayout = pLayoutItem->m_pNextSibling;
     XFA_ReleaseLayoutItem(pLayoutItem);
   }
 }
 FX_BOOL CXFA_LayoutPageMgr::InitLayoutPage(CXFA_Node* pFormNode) {
   PrepareLayout();
   CXFA_Node* pTemplateNode = pFormNode->GetTemplateNode();
   if (!pTemplateNode) {
     return FALSE;
   }
-  m_pTemplatePageSetRoot = pTemplateNode->GetProperty(0, XFA_ELEMENT_PageSet);
+  m_pTemplatePageSetRoot = pTemplateNode->GetProperty(0, XFA_Element::PageSet);
   ASSERT(m_pTemplatePageSetRoot);
   if (m_pPageSetLayoutItemRoot) {
     m_pPageSetLayoutItemRoot->m_pParent = NULL;
     m_pPageSetLayoutItemRoot->m_pFirstChild = NULL;
     m_pPageSetLayoutItemRoot->m_pNextSibling = NULL;
     m_pPageSetLayoutItemRoot->m_pFormNode = m_pTemplatePageSetRoot;
   } else {
     m_pPageSetLayoutItemRoot =
         new CXFA_ContainerLayoutItem(m_pTemplatePageSetRoot);
   }
   m_pPageSetCurRoot = m_pPageSetLayoutItemRoot;
   m_pTemplatePageSetRoot->SetUserData(XFA_LAYOUTITEMKEY,
                                       (void*)m_pPageSetLayoutItemRoot);
   XFA_ATTRIBUTEENUM eRelation =
       m_pTemplatePageSetRoot->GetEnum(XFA_ATTRIBUTE_Relation);
   if (eRelation != XFA_ATTRIBUTEENUM_Unknown) {
     m_ePageSetMode = eRelation;
   }
   InitPageSetMap();
   CXFA_Node* pPageArea = NULL;
   int32_t iCount = 0;
   for (pPageArea = m_pTemplatePageSetRoot->GetNodeItem(XFA_NODEITEM_FirstChild);
        pPageArea;
        pPageArea = pPageArea->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    if (pPageArea->GetClassID() == XFA_ELEMENT_PageArea) {
+    if (pPageArea->GetClassID() == XFA_Element::PageArea) {
       iCount++;
-      if (pPageArea->GetFirstChildByClass(XFA_ELEMENT_ContentArea)) {
+      if (pPageArea->GetFirstChildByClass(XFA_Element::ContentArea)) {
         return TRUE;
       }
     }
   }
   if (iCount > 0) {
     return FALSE;
   }
   CXFA_Document* pDocument = pTemplateNode->GetDocument();
   CXFA_Document* pObjFactory = pDocument->GetParser()->GetFactory();
-  pPageArea = m_pTemplatePageSetRoot->GetChild(0, XFA_ELEMENT_PageArea);
+  pPageArea = m_pTemplatePageSetRoot->GetChild(0, XFA_Element::PageArea);
   if (!pPageArea) {
     pPageArea = pObjFactory->CreateNode(m_pTemplatePageSetRoot->GetPacketID(),
-                                        XFA_ELEMENT_PageArea);
+                                        XFA_Element::PageArea);
     if (!pPageArea) {
       return FALSE;
     }
     m_pTemplatePageSetRoot->InsertChild(pPageArea, NULL);
     pPageArea->SetFlag(XFA_NodeFlag_Initialized, true);
   }
-  CXFA_Node* pContentArea = pPageArea->GetChild(0, XFA_ELEMENT_ContentArea);
+  CXFA_Node* pContentArea = pPageArea->GetChild(0, XFA_Element::ContentArea);
   if (!pContentArea) {
     pContentArea = pObjFactory->CreateNode(pPageArea->GetPacketID(),
-                                           XFA_ELEMENT_ContentArea);
+                                           XFA_Element::ContentArea);
     if (!pContentArea) {
       return FALSE;
     }
     pPageArea->InsertChild(pContentArea, NULL);
     pContentArea->SetFlag(XFA_NodeFlag_Initialized, true);
     pContentArea->SetMeasure(XFA_ATTRIBUTE_X,
                              CXFA_Measurement(0.25f, XFA_UNIT_In));
     pContentArea->SetMeasure(XFA_ATTRIBUTE_Y,
                              CXFA_Measurement(0.25f, XFA_UNIT_In));
     pContentArea->SetMeasure(XFA_ATTRIBUTE_W,
                              CXFA_Measurement(8.0f, XFA_UNIT_In));
     pContentArea->SetMeasure(XFA_ATTRIBUTE_H,
                              CXFA_Measurement(10.5f, XFA_UNIT_In));
   }
-  CXFA_Node* pMedium = pPageArea->GetChild(0, XFA_ELEMENT_Medium);
+  CXFA_Node* pMedium = pPageArea->GetChild(0, XFA_Element::Medium);
   if (!pMedium) {
     pMedium =
-        pObjFactory->CreateNode(pPageArea->GetPacketID(), XFA_ELEMENT_Medium);
+        pObjFactory->CreateNode(pPageArea->GetPacketID(), XFA_Element::Medium);
     if (!pContentArea) {
       return FALSE;
     }
     pPageArea->InsertChild(pMedium, NULL);
     pMedium->SetFlag(XFA_NodeFlag_Initialized, true);
     pMedium->SetMeasure(XFA_ATTRIBUTE_Short,
                         CXFA_Measurement(8.5f, XFA_UNIT_In));
     pMedium->SetMeasure(XFA_ATTRIBUTE_Long,
                         CXFA_Measurement(11.0f, XFA_UNIT_In));
   }
   return TRUE;
 }
 FX_BOOL CXFA_LayoutPageMgr::PrepareFirstPage(CXFA_Node* pRootSubform) {
   FX_BOOL bProBreakBefore = FALSE;
   CXFA_Node* pBreakBeforeNode = NULL;
   while (pRootSubform) {
     for (CXFA_Node* pBreakNode =
              pRootSubform->GetNodeItem(XFA_NODEITEM_FirstChild);
          pBreakNode;
          pBreakNode = pBreakNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-      XFA_ELEMENT eType = pBreakNode->GetClassID();
-      if (eType == XFA_ELEMENT_BreakBefore ||
-          (eType == XFA_ELEMENT_Break &&
+      XFA_Element eType = pBreakNode->GetClassID();
+      if (eType == XFA_Element::BreakBefore ||
+          (eType == XFA_Element::Break &&
            pBreakNode->GetEnum(XFA_ATTRIBUTE_Before) !=
                XFA_ATTRIBUTEENUM_Auto)) {
         bProBreakBefore = TRUE;
         pBreakBeforeNode = pBreakNode;
         break;
       }
     }
     if (bProBreakBefore) {
       break;
     }
     bProBreakBefore = TRUE;
-    pRootSubform = pRootSubform->GetFirstChildByClass(XFA_ELEMENT_Subform);
+    pRootSubform = pRootSubform->GetFirstChildByClass(XFA_Element::Subform);
     while (pRootSubform &&
            !XFA_ItemLayoutProcessor_IsTakingSpace(pRootSubform)) {
-      pRootSubform = pRootSubform->GetNextSameClassSibling(XFA_ELEMENT_Subform);
+      pRootSubform =
+          pRootSubform->GetNextSameClassSibling(XFA_Element::Subform);
     }
   }
   CXFA_Node *pLeader, *pTrailer;
   if (pBreakBeforeNode &&
       ExecuteBreakBeforeOrAfter(pBreakBeforeNode, TRUE, pLeader, pTrailer)) {
     m_pCurrentContainerRecord = m_rgProposedContainerRecord.GetHeadPosition();
     return TRUE;
   }
   return AppendNewPage(TRUE);
 }
@@ skipping 213 matching lines @@
         default: { ProcessLastPageSet(); } break;
         case XFA_ATTRIBUTEENUM_SimplexPaginated:
         case XFA_ATTRIBUTEENUM_DuplexPaginated: {
           CXFA_LayoutItem* pLastPageAreaLayoutItem = NULL;
           int32_t nPageAreaCount = 0;
           for (CXFA_LayoutItem* pPageAreaLayoutItem =
                    pPageSetLayoutItem->m_pFirstChild;
                pPageAreaLayoutItem;
                pPageAreaLayoutItem = pPageAreaLayoutItem->m_pNextSibling) {
             if (pPageAreaLayoutItem->m_pFormNode->GetClassID() !=
-                XFA_ELEMENT_PageArea) {
+                XFA_Element::PageArea) {
               continue;
             }
             nPageAreaCount++;
             pLastPageAreaLayoutItem = pPageAreaLayoutItem;
           }
           if (!pLastPageAreaLayoutItem) {
             break;
           }
           if (!FindPageAreaFromPageSet_SimplexDuplex(
                   pPageSetLayoutItem->m_pFormNode, NULL, NULL, NULL, TRUE, TRUE,
@@ skipping 22 matching lines @@
               break;
             }
           }
           FX_BOOL bUsable = TRUE;
           CFX_ArrayTemplate<FX_FLOAT> rgUsedHeights;
           for (CXFA_LayoutItem* pChildLayoutItem =
                    pLastPageAreaLayoutItem->m_pFirstChild;
                pChildLayoutItem;
                pChildLayoutItem = pChildLayoutItem->m_pNextSibling) {
             if (pChildLayoutItem->m_pFormNode->GetClassID() !=
-                XFA_ELEMENT_ContentArea) {
+                XFA_Element::ContentArea) {
               continue;
             }
             FX_FLOAT fUsedHeight = 0;
             for (CXFA_LayoutItem* pContentChildLayoutItem =
                      pChildLayoutItem->m_pFirstChild;
                  pContentChildLayoutItem;
                  pContentChildLayoutItem =
                      pContentChildLayoutItem->m_pNextSibling) {
               if (CXFA_ContentLayoutItem* pContent =
                       pContentChildLayoutItem->AsContentLayoutItem()) {
                 fUsedHeight += pContent->m_sSize.y;
               }
             }
             rgUsedHeights.Add(fUsedHeight);
           }
           int32_t iCurContentAreaIndex = -1;
           for (CXFA_Node* pContentAreaNode =
                    pNode->GetNodeItem(XFA_NODEITEM_FirstChild);
                pContentAreaNode;
                pContentAreaNode =
                    pContentAreaNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-            if (pContentAreaNode->GetClassID() != XFA_ELEMENT_ContentArea) {
+            if (pContentAreaNode->GetClassID() != XFA_Element::ContentArea) {
               continue;
             }
             iCurContentAreaIndex++;
             if (rgUsedHeights[iCurContentAreaIndex] >
                 pContentAreaNode->GetMeasure(XFA_ATTRIBUTE_H)
                         .ToUnit(XFA_UNIT_Pt) +
                     XFA_LAYOUT_FLOAT_PERCISION) {
               bUsable = FALSE;
               break;
             }
           }
           if (bUsable) {
             CXFA_LayoutItem* pChildLayoutItem =
                 pLastPageAreaLayoutItem->m_pFirstChild;
             CXFA_Node* pContentAreaNode =
                 pNode->GetNodeItem(XFA_NODEITEM_FirstChild);
             pLastPageAreaLayoutItem->m_pFormNode = pNode;
             while (pChildLayoutItem && pContentAreaNode) {
               if (pChildLayoutItem->m_pFormNode->GetClassID() !=
-                  XFA_ELEMENT_ContentArea) {
+                  XFA_Element::ContentArea) {
                 pChildLayoutItem = pChildLayoutItem->m_pNextSibling;
                 continue;
               }
-              if (pContentAreaNode->GetClassID() != XFA_ELEMENT_ContentArea) {
+              if (pContentAreaNode->GetClassID() != XFA_Element::ContentArea) {
                 pContentAreaNode =
                     pContentAreaNode->GetNodeItem(XFA_NODEITEM_NextSibling);
                 continue;
               }
               pChildLayoutItem->m_pFormNode = pContentAreaNode;
               pChildLayoutItem = pChildLayoutItem->m_pNextSibling;
               pContentAreaNode =
                   pContentAreaNode->GetNodeItem(XFA_NODEITEM_NextSibling);
             }
           } else if (pNode->GetEnum(XFA_ATTRIBUTE_PagePosition) ==
@@ skipping 12 matching lines @@
 CXFA_ContainerLayoutItem* CXFA_LayoutPageMgr::GetPage(int32_t index) const {
   if (index < 0 || index >= m_PageArray.GetSize())
     return nullptr;
   return m_PageArray[index];
 }
 int32_t CXFA_LayoutPageMgr::GetPageIndex(
     const CXFA_ContainerLayoutItem* pPage) const {
   // FIXME: Find() method should take const.
   return m_PageArray.Find(const_cast<CXFA_ContainerLayoutItem*>(pPage));
 }
-FX_BOOL CXFA_LayoutPageMgr::RunBreak(XFA_ELEMENT eBreakType,
+FX_BOOL CXFA_LayoutPageMgr::RunBreak(XFA_Element eBreakType,
                                      XFA_ATTRIBUTEENUM eTargetType,
                                      CXFA_Node* pTarget,
                                      FX_BOOL bStartNew) {
   FX_BOOL bRet = FALSE;
   switch (eTargetType) {
     case XFA_ATTRIBUTEENUM_ContentArea:
-      if (pTarget && pTarget->GetClassID() != XFA_ELEMENT_ContentArea) {
+      if (pTarget && pTarget->GetClassID() != XFA_Element::ContentArea) {
         pTarget = NULL;
       }
       if (!pTarget || !m_pCurrentContainerRecord ||
           pTarget !=
               GetCurrentContainerRecord()->pCurContentArea->m_pFormNode ||
           bStartNew) {
         CXFA_Node* pPageArea = NULL;
         if (pTarget) {
           pPageArea = pTarget->GetNodeItem(XFA_NODEITEM_Parent);
         }
         pPageArea = GetNextAvailPageArea(pPageArea, pTarget);
         bRet = pPageArea != NULL;
       }
       break;
     case XFA_ATTRIBUTEENUM_PageArea:
-      if (pTarget && pTarget->GetClassID() != XFA_ELEMENT_PageArea) {
+      if (pTarget && pTarget->GetClassID() != XFA_Element::PageArea) {
         pTarget = NULL;
       }
       if (!pTarget || !m_pCurrentContainerRecord ||
           pTarget != GetCurrentContainerRecord()->pCurPageArea->m_pFormNode ||
           bStartNew) {
         CXFA_Node* pPageArea = GetNextAvailPageArea(pTarget, NULL, TRUE);
         bRet = pPageArea != NULL;
       }
       break;
     case XFA_ATTRIBUTEENUM_PageOdd:
-      if (pTarget && pTarget->GetClassID() != XFA_ELEMENT_PageArea) {
+      if (pTarget && pTarget->GetClassID() != XFA_Element::PageArea) {
         pTarget = NULL;
       }
       break;
     case XFA_ATTRIBUTEENUM_PageEven:
-      if (pTarget && pTarget->GetClassID() != XFA_ELEMENT_PageArea) {
+      if (pTarget && pTarget->GetClassID() != XFA_Element::PageArea) {
         pTarget = NULL;
       }
       break;
     case XFA_ATTRIBUTEENUM_Auto:
     default:
       break;
   }
   return bRet;
 }
 FX_BOOL CXFA_LayoutPageMgr::ExecuteBreakBeforeOrAfter(
     CXFA_Node* pCurNode,
     FX_BOOL bBefore,
     CXFA_Node*& pBreakLeaderTemplate,
     CXFA_Node*& pBreakTrailerTemplate) {
-  XFA_ELEMENT eType = pCurNode->GetClassID();
+  XFA_Element eType = pCurNode->GetClassID();
   switch (eType) {
-    case XFA_ELEMENT_BreakBefore:
-    case XFA_ELEMENT_BreakAfter: {
+    case XFA_Element::BreakBefore:
+    case XFA_Element::BreakAfter: {
       CFX_WideStringC wsBreakLeader, wsBreakTrailer;
       CXFA_Node* pFormNode = pCurNode->GetNodeItem(
           XFA_NODEITEM_Parent, XFA_ObjectType::ContainerNode);
       CXFA_Node* pContainer = pFormNode->GetTemplateNode();
       FX_BOOL bStartNew = pCurNode->GetInteger(XFA_ATTRIBUTE_StartNew) != 0;
-      CXFA_Node* pScript = pCurNode->GetFirstChildByClass(XFA_ELEMENT_Script);
+      CXFA_Node* pScript = pCurNode->GetFirstChildByClass(XFA_Element::Script);
       if (pScript && !XFA_LayoutPageMgr_RunBreakTestScript(pScript)) {
         return FALSE;
       }
       CFX_WideStringC wsTarget = pCurNode->GetCData(XFA_ATTRIBUTE_Target);
       CXFA_Node* pTarget =
           ResolveBreakTarget(m_pTemplatePageSetRoot, TRUE, wsTarget);
       wsBreakTrailer = pCurNode->GetCData(XFA_ATTRIBUTE_Trailer);
       wsBreakLeader = pCurNode->GetCData(XFA_ATTRIBUTE_Leader);
       pBreakLeaderTemplate =
           ResolveBreakTarget(pContainer, TRUE, wsBreakLeader);
       pBreakTrailerTemplate =
           ResolveBreakTarget(pContainer, TRUE, wsBreakTrailer);
       if (RunBreak(eType, pCurNode->GetEnum(XFA_ATTRIBUTE_TargetType), pTarget,
                    bStartNew)) {
         return TRUE;
       } else {
         if (m_rgProposedContainerRecord.GetCount() > 0 &&
             m_pCurrentContainerRecord ==
                 m_rgProposedContainerRecord.GetHeadPosition() &&
-            eType == XFA_ELEMENT_BreakBefore) {
+            eType == XFA_Element::BreakBefore) {
           CXFA_Node* pParentNode = pFormNode->GetNodeItem(
               XFA_NODEITEM_Parent, XFA_ObjectType::ContainerNode);
           if (!pParentNode ||
               pFormNode !=
                   pParentNode->GetNodeItem(XFA_NODEITEM_FirstChild,
                                            XFA_ObjectType::ContainerNode)) {
             break;
           }
           pParentNode = pParentNode->GetNodeItem(XFA_NODEITEM_Parent);
-          if (!pParentNode || pParentNode->GetClassID() != XFA_ELEMENT_Form) {
+          if (!pParentNode || pParentNode->GetClassID() != XFA_Element::Form) {
             break;
           }
           return TRUE;
         }
       }
     } break;
-    case XFA_ELEMENT_Break: {
+    case XFA_Element::Break: {
       FX_BOOL bStartNew = pCurNode->GetInteger(XFA_ATTRIBUTE_StartNew) != 0;
       CFX_WideStringC wsTarget = pCurNode->GetCData(
           bBefore ? XFA_ATTRIBUTE_BeforeTarget : XFA_ATTRIBUTE_AfterTarget);
       CXFA_Node* pTarget =
           ResolveBreakTarget(m_pTemplatePageSetRoot, TRUE, wsTarget);
-      if (RunBreak(bBefore ? XFA_ELEMENT_BreakBefore : XFA_ELEMENT_BreakAfter,
+      if (RunBreak(bBefore ? XFA_Element::BreakBefore : XFA_Element::BreakAfter,
                    pCurNode->GetEnum(bBefore ? XFA_ATTRIBUTE_Before
                                              : XFA_ATTRIBUTE_After),
                    pTarget, bStartNew)) {
         return TRUE;
       }
     } break;
     default:
       break;
   }
   return FALSE;
@@ skipping 61 matching lines @@
   return FALSE;
 }
 CXFA_Node* CXFA_LayoutPageMgr::BreakOverflow(CXFA_Node* pOverflowNode,
                                              CXFA_Node*& pLeaderTemplate,
                                              CXFA_Node*& pTrailerTemplate,
                                              FX_BOOL bCreatePage) {
   CXFA_Node* pContainer =
       pOverflowNode
           ->GetNodeItem(XFA_NODEITEM_Parent, XFA_ObjectType::ContainerNode)
           ->GetTemplateNode();
-  if (pOverflowNode->GetClassID() == XFA_ELEMENT_Break) {
+  if (pOverflowNode->GetClassID() == XFA_Element::Break) {
     CFX_WideStringC wsOverflowLeader;
     CFX_WideStringC wsOverflowTarget;
     CFX_WideStringC wsOverflowTrailer;
     pOverflowNode->TryCData(XFA_ATTRIBUTE_OverflowLeader, wsOverflowLeader);
     pOverflowNode->TryCData(XFA_ATTRIBUTE_OverflowTrailer, wsOverflowTrailer);
     pOverflowNode->TryCData(XFA_ATTRIBUTE_OverflowTarget, wsOverflowTarget);
     if (!wsOverflowLeader.IsEmpty() || !wsOverflowTrailer.IsEmpty() ||
         !wsOverflowTarget.IsEmpty()) {
       if (!wsOverflowTarget.IsEmpty() && bCreatePage &&
           !m_bCreateOverFlowPage) {
         CXFA_Node* pTarget =
             ResolveBreakTarget(m_pTemplatePageSetRoot, TRUE, wsOverflowTarget);
         if (pTarget) {
           m_bCreateOverFlowPage = TRUE;
           switch (pTarget->GetClassID()) {
-            case XFA_ELEMENT_PageArea:
-              RunBreak(XFA_ELEMENT_Overflow, XFA_ATTRIBUTEENUM_PageArea,
+            case XFA_Element::PageArea:
+              RunBreak(XFA_Element::Overflow, XFA_ATTRIBUTEENUM_PageArea,
                        pTarget, TRUE);
               break;
-            case XFA_ELEMENT_ContentArea:
-              RunBreak(XFA_ELEMENT_Overflow, XFA_ATTRIBUTEENUM_ContentArea,
+            case XFA_Element::ContentArea:
+              RunBreak(XFA_Element::Overflow, XFA_ATTRIBUTEENUM_ContentArea,
                        pTarget, TRUE);
               break;
             default:
               break;
           }
         }
       }
       if (!bCreatePage) {
         pLeaderTemplate =
             ResolveBreakTarget(pContainer, TRUE, wsOverflowLeader);
         pTrailerTemplate =
             ResolveBreakTarget(pContainer, TRUE, wsOverflowTrailer);
       }
       return pOverflowNode;
     }
     return NULL;
-  } else if (pOverflowNode->GetClassID() == XFA_ELEMENT_Overflow) {
+  } else if (pOverflowNode->GetClassID() == XFA_Element::Overflow) {
     CFX_WideStringC wsOverflowLeader;
     CFX_WideStringC wsOverflowTrailer;
     CFX_WideStringC wsOverflowTarget;
     pOverflowNode->TryCData(XFA_ATTRIBUTE_Leader, wsOverflowLeader);
     pOverflowNode->TryCData(XFA_ATTRIBUTE_Trailer, wsOverflowTrailer);
     pOverflowNode->TryCData(XFA_ATTRIBUTE_Target, wsOverflowTarget);
     if (!wsOverflowTarget.IsEmpty() && bCreatePage && !m_bCreateOverFlowPage) {
       CXFA_Node* pTarget =
           ResolveBreakTarget(m_pTemplatePageSetRoot, TRUE, wsOverflowTarget);
       if (pTarget) {
         m_bCreateOverFlowPage = TRUE;
         switch (pTarget->GetClassID()) {
-          case XFA_ELEMENT_PageArea:
-            RunBreak(XFA_ELEMENT_Overflow, XFA_ATTRIBUTEENUM_PageArea, pTarget,
+          case XFA_Element::PageArea:
+            RunBreak(XFA_Element::Overflow, XFA_ATTRIBUTEENUM_PageArea, pTarget,
                      TRUE);
             break;
-          case XFA_ELEMENT_ContentArea:
-            RunBreak(XFA_ELEMENT_Overflow, XFA_ATTRIBUTEENUM_ContentArea,
+          case XFA_Element::ContentArea:
+            RunBreak(XFA_Element::Overflow, XFA_ATTRIBUTEENUM_ContentArea,
                      pTarget, TRUE);
             break;
           default:
             break;
         }
       }
     }
     if (!bCreatePage) {
       pLeaderTemplate = ResolveBreakTarget(pContainer, TRUE, wsOverflowLeader);
       pTrailerTemplate =
           ResolveBreakTarget(pContainer, TRUE, wsOverflowTrailer);
     }
     return pOverflowNode;
   }
   return nullptr;
 }
 
 FX_BOOL CXFA_LayoutPageMgr::ProcessOverflow(CXFA_Node* pFormNode,
                                             CXFA_Node*& pLeaderNode,
                                             CXFA_Node*& pTrailerNode,
                                             FX_BOOL bDataMerge,
                                             FX_BOOL bCreatePage) {
   if (pFormNode == NULL) {
     return FALSE;
   }
   CXFA_Node *pLeaderTemplate = NULL, *pTrailerTemplate = NULL;
   FX_BOOL bIsOverflowNode = FALSE;
-  if (pFormNode->GetClassID() == XFA_ELEMENT_Overflow ||
-      pFormNode->GetClassID() == XFA_ELEMENT_Break) {
+  if (pFormNode->GetClassID() == XFA_Element::Overflow ||
+      pFormNode->GetClassID() == XFA_Element::Break) {
     bIsOverflowNode = TRUE;
   }
   for (CXFA_Node* pCurNode =
            bIsOverflowNode ? pFormNode
                            : pFormNode->GetNodeItem(XFA_NODEITEM_FirstChild);
        pCurNode; pCurNode = pCurNode->GetNodeItem((XFA_NODEITEM_NextSibling))) {
     if (BreakOverflow(pCurNode, pLeaderTemplate, pTrailerTemplate,
                       bCreatePage)) {
       if (bIsOverflowNode) {
         pFormNode = pCurNode->GetNodeItem(XFA_NODEITEM_Parent);
@@ skipping 28 matching lines @@
 }
 FX_BOOL CXFA_LayoutPageMgr::ResolveBookendLeaderOrTrailer(
     CXFA_Node* pBookendNode,
     FX_BOOL bLeader,
     CXFA_Node*& pBookendAppendTemplate) {
   CFX_WideStringC wsBookendLeader;
   CXFA_Node* pContainer =
       pBookendNode
           ->GetNodeItem(XFA_NODEITEM_Parent, XFA_ObjectType::ContainerNode)
           ->GetTemplateNode();
-  if (pBookendNode->GetClassID() == XFA_ELEMENT_Break) {
+  if (pBookendNode->GetClassID() == XFA_Element::Break) {
     pBookendNode->TryCData(
         bLeader ? XFA_ATTRIBUTE_BookendLeader : XFA_ATTRIBUTE_BookendTrailer,
         wsBookendLeader);
     if (!wsBookendLeader.IsEmpty()) {
       pBookendAppendTemplate =
           ResolveBreakTarget(pContainer, FALSE, wsBookendLeader);
       return TRUE;
     }
     return FALSE;
-  } else if (pBookendNode->GetClassID() == XFA_ELEMENT_Bookend) {
+  } else if (pBookendNode->GetClassID() == XFA_Element::Bookend) {
     pBookendNode->TryCData(
         bLeader ? XFA_ATTRIBUTE_Leader : XFA_ATTRIBUTE_Trailer,
         wsBookendLeader);
     pBookendAppendTemplate =
         ResolveBreakTarget(pContainer, TRUE, wsBookendLeader);
     return TRUE;
   }
   return FALSE;
 }
 FX_BOOL CXFA_LayoutPageMgr::FindPageAreaFromPageSet(
@@ skipping 22 matching lines @@
     CXFA_Node* pPageSet,
     CXFA_Node* pStartChild,
     CXFA_Node* pTargetPageArea,
     CXFA_Node* pTargetContentArea,
     FX_BOOL bNewPage,
     FX_BOOL bQuery) {
   int32_t iPageSetCount = 0;
   if (!pStartChild && !bQuery) {
     m_pPageSetMap.Lookup(pPageSet, iPageSetCount);
     int32_t iMax = -1;
-    CXFA_Node* pOccurNode = pPageSet->GetFirstChildByClass(XFA_ELEMENT_Occur);
+    CXFA_Node* pOccurNode = pPageSet->GetFirstChildByClass(XFA_Element::Occur);
     if (pOccurNode) {
       pOccurNode->TryInteger(XFA_ATTRIBUTE_Max, iMax, FALSE);
     }
     if (iMax >= 0 && iMax <= iPageSetCount) {
       return FALSE;
     }
   }
   FX_BOOL bRes = FALSE;
   CXFA_Node* pCurrentNode =
       pStartChild ? pStartChild->GetNodeItem(XFA_NODEITEM_NextSibling)
                   : pPageSet->GetNodeItem(XFA_NODEITEM_FirstChild);
   for (; pCurrentNode;
        pCurrentNode = pCurrentNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    if (pCurrentNode->GetClassID() == XFA_ELEMENT_PageArea) {
+    if (pCurrentNode->GetClassID() == XFA_Element::PageArea) {
       if ((pTargetPageArea == pCurrentNode || pTargetPageArea == NULL)) {
-        if (pCurrentNode->GetFirstChildByClass(XFA_ELEMENT_ContentArea) ==
+        if (pCurrentNode->GetFirstChildByClass(XFA_Element::ContentArea) ==
             NULL) {
           if (pTargetPageArea == pCurrentNode) {
             CreateMinPageRecord(pCurrentNode, TRUE);
             pTargetPageArea = NULL;
           }
           continue;
         }
         if (!bQuery) {
           CXFA_ContainerRecord* pNewRecord =
               CreateContainerRecord(pCurrentNode, pStartChild == NULL);
           AddPageAreaLayoutItem(pNewRecord, pCurrentNode);
           if (pTargetContentArea == NULL) {
             pTargetContentArea =
-                pCurrentNode->GetFirstChildByClass(XFA_ELEMENT_ContentArea);
+                pCurrentNode->GetFirstChildByClass(XFA_Element::ContentArea);
           }
           AddContentAreaLayoutItem(pNewRecord, pTargetContentArea);
         }
         m_pCurPageArea = pCurrentNode;
         m_nCurPageCount = 1;
         bRes = TRUE;
         break;
       }
       if (!bQuery) {
         CreateMinPageRecord(pCurrentNode, FALSE);
       }
-    } else if (pCurrentNode->GetClassID() == XFA_ELEMENT_PageSet) {
+    } else if (pCurrentNode->GetClassID() == XFA_Element::PageSet) {
       if (FindPageAreaFromPageSet_Ordered(pCurrentNode, NULL, pTargetPageArea,
                                           pTargetContentArea, bNewPage,
                                           bQuery)) {
         bRes = TRUE;
         break;
       }
       if (!bQuery) {
         CreateMinPageSetRecord(pCurrentNode, TRUE);
       }
     }
   }
   if (!pStartChild && bRes && !bQuery) {
     m_pPageSetMap.SetAt(pPageSet, ++iPageSetCount);
   }
   return bRes;
 }
 FX_BOOL CXFA_LayoutPageMgr::FindPageAreaFromPageSet_SimplexDuplex(
     CXFA_Node* pPageSet,
     CXFA_Node* pStartChild,
     CXFA_Node* pTargetPageArea,
     CXFA_Node* pTargetContentArea,
     FX_BOOL bNewPage,
     FX_BOOL bQuery,
     XFA_ATTRIBUTEENUM ePreferredPosition) {
   const XFA_ATTRIBUTEENUM eFallbackPosition = XFA_ATTRIBUTEENUM_Any;
   CXFA_Node *pPreferredPageArea = NULL, *pFallbackPageArea = NULL;
   CXFA_Node* pCurrentNode = NULL;
-  if (!pStartChild || pStartChild->GetClassID() == XFA_ELEMENT_PageArea) {
+  if (!pStartChild || pStartChild->GetClassID() == XFA_Element::PageArea) {
     pCurrentNode = pPageSet->GetNodeItem(XFA_NODEITEM_FirstChild);
   } else {
     pCurrentNode = pStartChild->GetNodeItem(XFA_NODEITEM_NextSibling);
   }
   for (; pCurrentNode;
        pCurrentNode = pCurrentNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    if (pCurrentNode->GetClassID() == XFA_ELEMENT_PageArea) {
+    if (pCurrentNode->GetClassID() == XFA_Element::PageArea) {
       if (!MatchPageAreaOddOrEven(pCurrentNode, FALSE)) {
         continue;
       }
       XFA_ATTRIBUTEENUM eCurPagePosition =
           pCurrentNode->GetEnum(XFA_ATTRIBUTE_PagePosition);
       if (ePreferredPosition == XFA_ATTRIBUTEENUM_Last) {
         if (eCurPagePosition != ePreferredPosition) {
           continue;
         }
         if (m_ePageSetMode == XFA_ATTRIBUTEENUM_SimplexPaginated ||
             pCurrentNode->GetEnum(XFA_ATTRIBUTE_OddOrEven) ==
                 XFA_ATTRIBUTEENUM_Any) {
           pPreferredPageArea = pCurrentNode;
           break;
         }
         CXFA_ContainerRecord* pNewRecord = CreateContainerRecord();
         AddPageAreaLayoutItem(pNewRecord, pCurrentNode);
         AddContentAreaLayoutItem(pNewRecord, pCurrentNode->GetFirstChildByClass(
-                                                 XFA_ELEMENT_ContentArea));
+                                                 XFA_Element::ContentArea));
         pPreferredPageArea = pCurrentNode;
         return FALSE;
       } else if (ePreferredPosition == XFA_ATTRIBUTEENUM_Only) {
         if (eCurPagePosition != ePreferredPosition) {
           continue;
         }
         if (m_ePageSetMode != XFA_ATTRIBUTEENUM_DuplexPaginated ||
             pCurrentNode->GetEnum(XFA_ATTRIBUTE_OddOrEven) ==
                 XFA_ATTRIBUTEENUM_Any) {
           pPreferredPageArea = pCurrentNode;
           break;
         }
         return FALSE;
       }
       if ((pTargetPageArea == pCurrentNode || pTargetPageArea == NULL)) {
-        if (pCurrentNode->GetFirstChildByClass(XFA_ELEMENT_ContentArea) ==
+        if (pCurrentNode->GetFirstChildByClass(XFA_Element::ContentArea) ==
             NULL) {
           if (pTargetPageArea == pCurrentNode) {
             CXFA_ContainerRecord* pNewRecord = CreateContainerRecord();
             AddPageAreaLayoutItem(pNewRecord, pCurrentNode);
             pTargetPageArea = NULL;
           }
           continue;
         }
         if ((ePreferredPosition == XFA_ATTRIBUTEENUM_Rest &&
              eCurPagePosition == XFA_ATTRIBUTEENUM_Any) ||
             eCurPagePosition == ePreferredPosition) {
           pPreferredPageArea = pCurrentNode;
           break;
         } else if (eCurPagePosition == eFallbackPosition &&
                    !pFallbackPageArea) {
           pFallbackPageArea = pCurrentNode;
         }
       } else if (pTargetPageArea &&
                  !MatchPageAreaOddOrEven(pTargetPageArea, FALSE)) {
         CXFA_ContainerRecord* pNewRecord = CreateContainerRecord();
         AddPageAreaLayoutItem(pNewRecord, pCurrentNode);
         AddContentAreaLayoutItem(pNewRecord, pCurrentNode->GetFirstChildByClass(
-                                                 XFA_ELEMENT_ContentArea));
+                                                 XFA_Element::ContentArea));
       }
-    } else if (pCurrentNode->GetClassID() == XFA_ELEMENT_PageSet) {
+    } else if (pCurrentNode->GetClassID() == XFA_Element::PageSet) {
       if (FindPageAreaFromPageSet_SimplexDuplex(
               pCurrentNode, NULL, pTargetPageArea, pTargetContentArea, bNewPage,
               bQuery, ePreferredPosition)) {
         break;
       }
     }
   }
   CXFA_Node* pCurPageArea = NULL;
   if (pPreferredPageArea) {
     pCurPageArea = pPreferredPageArea;
   } else if (pFallbackPageArea) {
     pCurPageArea = pFallbackPageArea;
   }
   if (!pCurPageArea) {
     return FALSE;
   }
   if (!bQuery) {
     CXFA_ContainerRecord* pNewRecord = CreateContainerRecord();
     AddPageAreaLayoutItem(pNewRecord, pCurPageArea);
     if (pTargetContentArea == NULL) {
       pTargetContentArea =
-          pCurPageArea->GetFirstChildByClass(XFA_ELEMENT_ContentArea);
+          pCurPageArea->GetFirstChildByClass(XFA_Element::ContentArea);
     }
     AddContentAreaLayoutItem(pNewRecord, pTargetContentArea);
   }
   m_pCurPageArea = pCurPageArea;
   return TRUE;
 }
 FX_BOOL CXFA_LayoutPageMgr::MatchPageAreaOddOrEven(CXFA_Node* pPageArea,
                                                    FX_BOOL bLastMatch) {
   if (m_ePageSetMode != XFA_ATTRIBUTEENUM_DuplexPaginated) {
     return TRUE;
@@ skipping 22 matching lines @@
     ASSERT(m_pCurPageArea);
     return m_pCurPageArea;
   }
   if (pTargetPageArea == NULL || pTargetPageArea == m_pCurPageArea) {
     if (!bNewPage && GetNextContentArea(pTargetContentArea)) {
       return m_pCurPageArea;
     }
     if (IsPageSetRootOrderedOccurrence()) {
       int32_t iMax = -1;
       CXFA_Node* pOccurNode =
-          m_pCurPageArea->GetFirstChildByClass(XFA_ELEMENT_Occur);
+          m_pCurPageArea->GetFirstChildByClass(XFA_Element::Occur);
       if (pOccurNode) {
         pOccurNode->TryInteger(XFA_ATTRIBUTE_Max, iMax, FALSE);
       }
       if ((iMax < 0 || m_nCurPageCount < iMax)) {
         if (!bQuery) {
           CXFA_ContainerRecord* pNewRecord =
               CreateContainerRecord(m_pCurPageArea);
           AddPageAreaLayoutItem(pNewRecord, m_pCurPageArea);
           if (pTargetContentArea == NULL) {
             pTargetContentArea =
-                m_pCurPageArea->GetFirstChildByClass(XFA_ELEMENT_ContentArea);
+                m_pCurPageArea->GetFirstChildByClass(XFA_Element::ContentArea);
           }
           AddContentAreaLayoutItem(pNewRecord, pTargetContentArea);
         }
         m_nCurPageCount++;
         return m_pCurPageArea;
       }
     }
   }
   if (!bQuery && IsPageSetRootOrderedOccurrence()) {
     CreateMinPageRecord(m_pCurPageArea, FALSE, TRUE);
@@ skipping 22 matching lines @@
     pPageSet = pPageSet->GetNodeItem(XFA_NODEITEM_Parent);
   }
   return NULL;
 }
 
 FX_BOOL CXFA_LayoutPageMgr::GetNextContentArea(CXFA_Node* pContentArea) {
   CXFA_Node* pCurContentNode =
       GetCurrentContainerRecord()->pCurContentArea->m_pFormNode;
   if (pContentArea == NULL) {
     pContentArea =
-        pCurContentNode->GetNextSameClassSibling(XFA_ELEMENT_ContentArea);
+        pCurContentNode->GetNextSameClassSibling(XFA_Element::ContentArea);
     if (pContentArea == NULL) {
       return FALSE;
     }
   } else {
     if (pContentArea->GetNodeItem(XFA_NODEITEM_Parent) != m_pCurPageArea) {
       return FALSE;
     }
     CXFA_ContainerLayoutItem* pContentAreaLayout = NULL;
     if (!CheckContentAreaNotUsed(GetCurrentContainerRecord()->pCurPageArea,
                                  pContentArea, pContentAreaLayout)) {
@@ skipping 13 matching lines @@
   AddContentAreaLayoutItem(pNewRecord, pContentArea);
   return TRUE;
 }
 void CXFA_LayoutPageMgr::InitPageSetMap() {
   if (!IsPageSetRootOrderedOccurrence()) {
     return;
   }
   CXFA_NodeIterator sIterator(m_pTemplatePageSetRoot);
   for (CXFA_Node* pPageSetNode = sIterator.GetCurrent(); pPageSetNode;
        pPageSetNode = sIterator.MoveToNext()) {
-    if (pPageSetNode->GetClassID() == XFA_ELEMENT_PageSet) {
+    if (pPageSetNode->GetClassID() == XFA_Element::PageSet) {
       XFA_ATTRIBUTEENUM eRelation =
           pPageSetNode->GetEnum(XFA_ATTRIBUTE_Relation);
       if (eRelation == XFA_ATTRIBUTEENUM_OrderedOccurrence) {
         m_pPageSetMap.SetAt(pPageSetNode, 0);
       }
     }
   }
 }
 int32_t CXFA_LayoutPageMgr::CreateMinPageRecord(CXFA_Node* pPageArea,
                                                 FX_BOOL bTargetPageArea,
                                                 FX_BOOL bCreateLast) {
   if (pPageArea == NULL) {
     return 0;
   }
-  CXFA_Node* pOccurNode = pPageArea->GetFirstChildByClass(XFA_ELEMENT_Occur);
+  CXFA_Node* pOccurNode = pPageArea->GetFirstChildByClass(XFA_Element::Occur);
   int32_t iMin = 0;
   if ((pOccurNode && pOccurNode->TryInteger(XFA_ATTRIBUTE_Min, iMin, FALSE)) ||
       bTargetPageArea) {
     CXFA_Node* pContentArea =
-        pPageArea->GetFirstChildByClass(XFA_ELEMENT_ContentArea);
+        pPageArea->GetFirstChildByClass(XFA_Element::ContentArea);
     if (iMin < 1 && bTargetPageArea && !pContentArea) {
       iMin = 1;
     }
     int32_t i = 0;
     if (bCreateLast) {
       i = m_nCurPageCount;
     }
     for (; i < iMin; i++) {
       CXFA_ContainerRecord* pNewRecord = CreateContainerRecord();
       AddPageAreaLayoutItem(pNewRecord, pPageArea);
       AddContentAreaLayoutItem(pNewRecord, pContentArea);
     }
   }
   return iMin;
 }
 void CXFA_LayoutPageMgr::CreateMinPageSetRecord(CXFA_Node* pPageSet,
                                                 FX_BOOL bCreateAll) {
   if (pPageSet == NULL) {
     return;
   }
   int32_t iCurSetCount = 0;
   if (!m_pPageSetMap.Lookup(pPageSet, iCurSetCount)) {
     return;
   }
   if (bCreateAll) {
     iCurSetCount = 0;
   }
-  CXFA_Node* pOccurNode = pPageSet->GetFirstChildByClass(XFA_ELEMENT_Occur);
+  CXFA_Node* pOccurNode = pPageSet->GetFirstChildByClass(XFA_Element::Occur);
   int32_t iMin = 0;
   if (pOccurNode && pOccurNode->TryInteger(XFA_ATTRIBUTE_Min, iMin, FALSE)) {
     if (iCurSetCount < iMin) {
       for (int32_t i = 0; i < iMin - iCurSetCount; i++) {
         for (CXFA_Node* pCurrentPageNode =
                  pPageSet->GetNodeItem(XFA_NODEITEM_FirstChild);
              pCurrentPageNode; pCurrentPageNode = pCurrentPageNode->GetNodeItem(
                                    XFA_NODEITEM_NextSibling)) {
-          if (pCurrentPageNode->GetClassID() == XFA_ELEMENT_PageArea) {
+          if (pCurrentPageNode->GetClassID() == XFA_Element::PageArea) {
             CreateMinPageRecord(pCurrentPageNode, FALSE);
-          } else if (pCurrentPageNode->GetClassID() == XFA_ELEMENT_PageSet) {
+          } else if (pCurrentPageNode->GetClassID() == XFA_Element::PageSet) {
             CreateMinPageSetRecord(pCurrentPageNode, TRUE);
           }
         }
       }
       m_pPageSetMap.SetAt(pPageSet, iMin);
     }
   }
 }
 void CXFA_LayoutPageMgr::CreateNextMinRecord(CXFA_Node* pRecordNode) {
   if (pRecordNode == NULL) {
     return;
   }
   for (CXFA_Node* pCurrentNode =
            pRecordNode->GetNodeItem(XFA_NODEITEM_NextSibling);
        pCurrentNode;
        pCurrentNode = pCurrentNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    if (pCurrentNode->GetClassID() == XFA_ELEMENT_PageArea) {
+    if (pCurrentNode->GetClassID() == XFA_Element::PageArea) {
       CreateMinPageRecord(pCurrentNode, FALSE);
-    } else if (pCurrentNode->GetClassID() == XFA_ELEMENT_PageSet) {
+    } else if (pCurrentNode->GetClassID() == XFA_Element::PageSet) {
       CreateMinPageSetRecord(pCurrentNode, TRUE);
     }
   }
 }
 void CXFA_LayoutPageMgr::ProcessLastPageSet() {
   CreateMinPageRecord(m_pCurPageArea, FALSE, TRUE);
   CreateNextMinRecord(m_pCurPageArea);
   CXFA_Node* pPageSet = m_pCurPageArea->GetNodeItem(XFA_NODEITEM_Parent);
   while (TRUE) {
     CreateMinPageSetRecord(pPageSet);
     if (pPageSet == m_pTemplatePageSetRoot) {
       break;
     }
     CreateNextMinRecord(pPageSet);
     pPageSet = pPageSet->GetNodeItem(XFA_NODEITEM_Parent);
   }
 }
 FX_BOOL CXFA_LayoutPageMgr::GetNextAvailContentHeight(FX_FLOAT fChildHeight) {
   CXFA_Node* pCurContentNode =
       GetCurrentContainerRecord()->pCurContentArea->m_pFormNode;
   if (pCurContentNode == NULL) {
     return FALSE;
   }
   pCurContentNode =
-      pCurContentNode->GetNextSameClassSibling(XFA_ELEMENT_ContentArea);
+      pCurContentNode->GetNextSameClassSibling(XFA_Element::ContentArea);
   if (pCurContentNode) {
     FX_FLOAT fNextContentHeight =
         pCurContentNode->GetMeasure(XFA_ATTRIBUTE_H).ToUnit(XFA_UNIT_Pt);
     return fNextContentHeight > fChildHeight;
   }
   CXFA_Node* pPageNode = GetCurrentContainerRecord()->pCurPageArea->m_pFormNode;
-  CXFA_Node* pOccurNode = pPageNode->GetFirstChildByClass(XFA_ELEMENT_Occur);
+  CXFA_Node* pOccurNode = pPageNode->GetFirstChildByClass(XFA_Element::Occur);
   int32_t iMax = 0;
   if (pOccurNode && pOccurNode->TryInteger(XFA_ATTRIBUTE_Max, iMax, FALSE)) {
     if (m_nCurPageCount == iMax) {
       CXFA_Node* pSrcPage = m_pCurPageArea;
       int32_t nSrcPageCount = m_nCurPageCount;
       FX_POSITION psSrcRecord = m_rgProposedContainerRecord.GetTailPosition();
       CXFA_Node* pNextPage = GetNextAvailPageArea(NULL, NULL, FALSE, TRUE);
       m_pCurPageArea = pSrcPage;
       m_nCurPageCount = nSrcPageCount;
       CXFA_ContainerRecord* pPrevRecord =
           (CXFA_ContainerRecord*)m_rgProposedContainerRecord.GetNext(
               psSrcRecord);
       while (psSrcRecord) {
         FX_POSITION psSaveRecord = psSrcRecord;
         CXFA_ContainerRecord* pInsertRecord =
             (CXFA_ContainerRecord*)m_rgProposedContainerRecord.GetNext(
                 psSrcRecord);
         RemoveLayoutRecord(pInsertRecord, pPrevRecord);
         delete pInsertRecord;
         m_rgProposedContainerRecord.RemoveAt(psSaveRecord);
       }
       if (pNextPage) {
         CXFA_Node* pContentArea =
-            pNextPage->GetFirstChildByClass(XFA_ELEMENT_ContentArea);
+            pNextPage->GetFirstChildByClass(XFA_Element::ContentArea);
         if (pContentArea) {
           FX_FLOAT fNextContentHeight =
               pContentArea->GetMeasure(XFA_ATTRIBUTE_H).ToUnit(XFA_UNIT_Pt);
           if (fNextContentHeight > fChildHeight) {
             return TRUE;
           }
         }
       }
       return FALSE;
     }
   }
   CXFA_Node* pContentArea =
-      pPageNode->GetFirstChildByClass(XFA_ELEMENT_ContentArea);
+      pPageNode->GetFirstChildByClass(XFA_Element::ContentArea);
   FX_FLOAT fNextContentHeight =
       pContentArea->GetMeasure(XFA_ATTRIBUTE_H).ToUnit(XFA_UNIT_Pt);
   if (fNextContentHeight < XFA_LAYOUT_FLOAT_PERCISION) {
     return TRUE;
   }
   if (fNextContentHeight > fChildHeight) {
     return TRUE;
   }
   return FALSE;
 }
@@ skipping 54 matching lines @@
         }
       }
     }
     if (pCurLayoutItem->m_pFirstChild) {
       SaveLayoutItem(pCurLayoutItem);
     }
     pCurLayoutItem->m_pParent = NULL;
     pCurLayoutItem->m_pNextSibling = NULL;
     pCurLayoutItem->m_pFirstChild = NULL;
     if (!pCurLayoutItem->IsContentLayoutItem() &&
-        pCurLayoutItem->m_pFormNode->GetClassID() != XFA_ELEMENT_PageArea) {
+        pCurLayoutItem->m_pFormNode->GetClassID() != XFA_Element::PageArea) {
       delete pCurLayoutItem;
     }
     pCurLayoutItem = pNextLayoutItem;
   }
 }
 CXFA_Node* CXFA_LayoutPageMgr::QueryOverflow(
     CXFA_Node* pFormNode,
     CXFA_LayoutContext* pLayoutContext) {
   for (CXFA_Node* pCurNode = pFormNode->GetNodeItem(XFA_NODEITEM_FirstChild);
        pCurNode; pCurNode = pCurNode->GetNodeItem((XFA_NODEITEM_NextSibling))) {
-    if (pCurNode->GetClassID() == XFA_ELEMENT_Break) {
+    if (pCurNode->GetClassID() == XFA_Element::Break) {
       CFX_WideStringC wsOverflowLeader;
       CFX_WideStringC wsOverflowTarget;
       CFX_WideStringC wsOverflowTrailer;
       pCurNode->TryCData(XFA_ATTRIBUTE_OverflowLeader, wsOverflowLeader);
       pCurNode->TryCData(XFA_ATTRIBUTE_OverflowTrailer, wsOverflowTrailer);
       pCurNode->TryCData(XFA_ATTRIBUTE_OverflowTarget, wsOverflowTarget);
       if (!wsOverflowLeader.IsEmpty() || !wsOverflowTrailer.IsEmpty() ||
           !wsOverflowTarget.IsEmpty()) {
         return pCurNode;
       }
       return NULL;
-    } else if (pCurNode->GetClassID() == XFA_ELEMENT_Overflow) {
+    } else if (pCurNode->GetClassID() == XFA_Element::Overflow) {
       return pCurNode;
     }
   }
   return NULL;
 }
 
 void CXFA_LayoutPageMgr::MergePageSetContents() {
   CXFA_Document* pDocument = m_pTemplatePageSetRoot->GetDocument();
   CXFA_FFNotify* pNotify = pDocument->GetParser()->GetNotify();
   CXFA_LayoutProcessor* pDocLayout = pDocument->GetDocLayout();
@@ skipping 19 matching lines @@
   int32_t iIndex = 0;
   for (; pRootLayout;
        pRootLayout = (CXFA_ContainerLayoutItem*)pRootLayout->m_pNextSibling) {
     CXFA_Node* pPendingPageSet = nullptr;
     CXFA_NodeIteratorTemplate<
         CXFA_ContainerLayoutItem,
         CXFA_TraverseStrategy_ContentAreaContainerLayoutItem>
         iterator(pRootLayout);
     CXFA_ContainerLayoutItem* pRootPageSetContainerItem = iterator.GetCurrent();
     ASSERT(pRootPageSetContainerItem->m_pFormNode->GetClassID() ==
-           XFA_ELEMENT_PageSet);
+           XFA_Element::PageSet);
     if (iIndex < pDocument->m_pPendingPageSet.GetSize()) {
       pPendingPageSet = pDocument->m_pPendingPageSet.GetAt(iIndex);
       iIndex++;
     }
     if (!pPendingPageSet) {
       if (pRootPageSetContainerItem->m_pFormNode->GetPacketID() ==
           XFA_XDPPACKET_Template) {
         pPendingPageSet =
             pRootPageSetContainerItem->m_pFormNode->CloneTemplateToForm(FALSE);
       } else {
         pPendingPageSet = pRootPageSetContainerItem->m_pFormNode;
       }
     }
     if (pRootPageSetContainerItem->m_pFormNode->GetUserData(
             XFA_LAYOUTITEMKEY) == pRootPageSetContainerItem) {
       pRootPageSetContainerItem->m_pFormNode->SetUserData(XFA_LAYOUTITEMKEY,
                                                           NULL);
     }
     pRootPageSetContainerItem->m_pFormNode = pPendingPageSet;
     pPendingPageSet->ClearFlag(XFA_NodeFlag_UnusedNode);
     for (CXFA_ContainerLayoutItem* pContainerItem = iterator.MoveToNext();
          pContainerItem; pContainerItem = iterator.MoveToNext()) {
       CXFA_Node* pNode = pContainerItem->m_pFormNode;
       if (pNode->GetPacketID() != XFA_XDPPACKET_Template) {
         continue;
       }
       switch (pNode->GetClassID()) {
-        case XFA_ELEMENT_PageSet: {
+        case XFA_Element::PageSet: {
           CXFA_Node* pParentNode = pContainerItem->m_pParent->m_pFormNode;
           pContainerItem->m_pFormNode = XFA_NodeMerge_CloneOrMergeContainer(
               pDocument, pParentNode, pContainerItem->m_pFormNode, TRUE);
         } break;
-        case XFA_ELEMENT_PageArea: {
+        case XFA_Element::PageArea: {
           CXFA_ContainerLayoutItem* pFormLayout = pContainerItem;
           CXFA_Node* pParentNode = pContainerItem->m_pParent->m_pFormNode;
           FX_BOOL bIsExistForm = TRUE;
           for (int32_t iLevel = 0; iLevel < 3; iLevel++) {
             pFormLayout = (CXFA_ContainerLayoutItem*)pFormLayout->m_pFirstChild;
             if (iLevel == 2) {
               while (pFormLayout &&
                      !XFA_ItemLayoutProcessor_IsTakingSpace(
                          pFormLayout->m_pFormNode)) {
                 pFormLayout =
                     (CXFA_ContainerLayoutItem*)pFormLayout->m_pNextSibling;
               }
             }
             if (pFormLayout == NULL) {
               bIsExistForm = FALSE;
               break;
             }
           }
           if (bIsExistForm) {
             CXFA_Node* pNewSubform = pFormLayout->m_pFormNode;
             if (pContainerItem->m_pOldSubform &&
                 pContainerItem->m_pOldSubform != pNewSubform) {
               CXFA_Node* pExistingNode = XFA_DataMerge_FindFormDOMInstance(
                   pDocument, pContainerItem->m_pFormNode->GetClassID(),
                   pContainerItem->m_pFormNode->GetNameHash(), pParentNode);
               CXFA_ContainerIterator sIterator(pExistingNode);
               for (CXFA_Node* pIter = sIterator.GetCurrent(); pIter;
                    pIter = sIterator.MoveToNext()) {
-                if (pIter->GetClassID() != XFA_ELEMENT_ContentArea) {
+                if (pIter->GetClassID() != XFA_Element::ContentArea) {
                   CXFA_LayoutItem* pLayoutItem = static_cast<CXFA_LayoutItem*>(
                       pIter->GetUserData(XFA_LAYOUTITEMKEY));
                   if (pLayoutItem) {
                     pNotify->OnLayoutItemRemoving(pDocLayout, pLayoutItem);
                     delete pLayoutItem;
                   }
                 }
               }
               if (pExistingNode) {
                 pParentNode->RemoveChild(pExistingNode);
               }
             }
             pContainerItem->m_pOldSubform = pNewSubform;
           }
           pContainerItem->m_pFormNode = pDocument->DataMerge_CopyContainer(
               pContainerItem->m_pFormNode, pParentNode,
               ToNode(pDocument->GetXFAObject(XFA_HASHCODE_Record)), TRUE);
         } break;
-        case XFA_ELEMENT_ContentArea: {
+        case XFA_Element::ContentArea: {
           CXFA_Node* pParentNode = pContainerItem->m_pParent->m_pFormNode;
           for (CXFA_Node* pChildNode =
                    pParentNode->GetNodeItem(XFA_NODEITEM_FirstChild);
                pChildNode;
                pChildNode = pChildNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
             if (pChildNode->GetTemplateNode() != pContainerItem->m_pFormNode) {
               continue;
             }
             pContainerItem->m_pFormNode = pChildNode;
             break;
           }
         } break;
         default:
           break;
       }
     }
     if (!pPendingPageSet->GetNodeItem(XFA_NODEITEM_Parent)) {
       CXFA_Node* pFormToplevelSubform =
           pDocument->GetXFAObject(XFA_HASHCODE_Form)
               ->AsNode()
-              ->GetFirstChildByClass(XFA_ELEMENT_Subform);
+              ->GetFirstChildByClass(XFA_Element::Subform);
       pFormToplevelSubform->InsertChild(pPendingPageSet);
     }
     pDocument->DataMerge_UpdateBindingRelations(pPendingPageSet);
     pPendingPageSet->SetFlag(XFA_NodeFlag_Initialized, true);
   }
   CXFA_Node* pPageSet = GetRootLayoutItem()->m_pFormNode;
   while (pPageSet) {
     CXFA_Node* pNextPageSet =
-        pPageSet->GetNextSameClassSibling(XFA_ELEMENT_PageSet);
+        pPageSet->GetNextSameClassSibling(XFA_Element::PageSet);
     CXFA_NodeIteratorTemplate<CXFA_Node, CXFA_TraverseStrategy_XFANode>
         sIterator(pPageSet);
     CXFA_Node* pNode = sIterator.GetCurrent();
     while (pNode) {
       if (pNode->IsUnusedNode()) {
         if (pNode->IsContainerNode()) {
-          XFA_ELEMENT eCurId = pNode->GetClassID();
-          if (eCurId == XFA_ELEMENT_PageArea || eCurId == XFA_ELEMENT_PageSet) {
+          XFA_Element eCurId = pNode->GetClassID();
+          if (eCurId == XFA_Element::PageArea ||
+              eCurId == XFA_Element::PageSet) {
             CXFA_ContainerIterator iteChild(pNode);
             CXFA_Node* pChildNode = iteChild.MoveToNext();
             for (; pChildNode; pChildNode = iteChild.MoveToNext()) {
               CXFA_LayoutItem* pLayoutItem = static_cast<CXFA_LayoutItem*>(
                   pChildNode->GetUserData(XFA_LAYOUTITEMKEY));
               if (pLayoutItem) {
                 pNotify->OnLayoutItemRemoving(pDocLayout, pLayoutItem);
                 delete pLayoutItem;
               }
             }
-          } else if (eCurId != XFA_ELEMENT_ContentArea) {
+          } else if (eCurId != XFA_Element::ContentArea) {
             CXFA_LayoutItem* pLayoutItem = static_cast<CXFA_LayoutItem*>(
                 pNode->GetUserData(XFA_LAYOUTITEMKEY));
             if (pLayoutItem) {
               pNotify->OnLayoutItemRemoving(pDocLayout, pLayoutItem);
               delete pLayoutItem;
             }
           }
           CXFA_Node* pNext = sIterator.SkipChildrenAndMoveToNext();
           pNode->GetNodeItem(XFA_NODEITEM_Parent)->RemoveChild(pNode);
           pNode = pNext;
@@ skipping 17 matching lines @@
        pRootLayoutItem =
            (CXFA_ContainerLayoutItem*)pRootLayoutItem->m_pNextSibling) {
     CXFA_NodeIteratorTemplate<
         CXFA_ContainerLayoutItem,
         CXFA_TraverseStrategy_ContentAreaContainerLayoutItem>
         iterator(pRootLayoutItem);
     for (CXFA_ContainerLayoutItem* pContainerItem = iterator.GetCurrent();
          pContainerItem; pContainerItem = iterator.MoveToNext()) {
       CXFA_Node* pNode = pContainerItem->m_pFormNode;
       switch (pNode->GetClassID()) {
-        case XFA_ELEMENT_PageArea:
+        case XFA_Element::PageArea:
           m_pLayoutProcessor->GetRootRootItemLayoutProcessor()
               ->DoLayoutPageArea(pContainerItem);
           break;
         default:
           break;
       }
     }
   }
 }
 
 void CXFA_LayoutPageMgr::SyncLayoutData() {
   MergePageSetContents();
   LayoutPageSetContents();
   CXFA_FFNotify* pNotify =
       m_pTemplatePageSetRoot->GetDocument()->GetParser()->GetNotify();
   int32_t nPageIdx = -1;
   CXFA_ContainerLayoutItem* pRootLayoutItem = GetRootLayoutItem();
   for (; pRootLayoutItem;
        pRootLayoutItem =
            (CXFA_ContainerLayoutItem*)pRootLayoutItem->m_pNextSibling) {
     CXFA_NodeIteratorTemplate<
         CXFA_ContainerLayoutItem,
         CXFA_TraverseStrategy_ContentAreaContainerLayoutItem>
         iteratorParent(pRootLayoutItem);
     for (CXFA_ContainerLayoutItem* pContainerItem = iteratorParent.GetCurrent();
          pContainerItem; pContainerItem = iteratorParent.MoveToNext()) {
       switch (pContainerItem->m_pFormNode->GetClassID()) {
-        case XFA_ELEMENT_PageArea: {
+        case XFA_Element::PageArea: {
           nPageIdx++;
           uint32_t dwRelevant =
               XFA_WidgetStatus_Viewable | XFA_WidgetStatus_Printable;
           CXFA_NodeIteratorTemplate<CXFA_LayoutItem,
                                     CXFA_TraverseStrategy_LayoutItem>
               iterator(pContainerItem);
           CXFA_LayoutItem* pChildLayoutItem = iterator.GetCurrent();
           while (pChildLayoutItem) {
             CXFA_ContentLayoutItem* pContentItem =
                 pChildLayoutItem->AsContentLayoutItem();
@@ skipping 26 matching lines @@
   ClearRecordList();
 }
 void XFA_ReleaseLayoutItem_NoPageArea(CXFA_LayoutItem* pLayoutItem) {
   CXFA_LayoutItem *pNext, *pNode = pLayoutItem->m_pFirstChild;
   while (pNode) {
     pNext = pNode->m_pNextSibling;
     pNode->m_pParent = NULL;
     XFA_ReleaseLayoutItem_NoPageArea(pNode);
     pNode = pNext;
   }
-  if (pLayoutItem->m_pFormNode->GetClassID() != XFA_ELEMENT_PageArea) {
+  if (pLayoutItem->m_pFormNode->GetClassID() != XFA_Element::PageArea) {
     delete pLayoutItem;
   }
 }
 void CXFA_LayoutPageMgr::PrepareLayout() {
   m_pPageSetCurRoot = NULL;
   m_ePageSetMode = XFA_ATTRIBUTEENUM_OrderedOccurrence;
   m_nAvailPages = 0;
   ClearRecordList();
   if (!m_pPageSetLayoutItemRoot) {
     return;
   }
   CXFA_ContainerLayoutItem* pRootLayoutItem = m_pPageSetLayoutItemRoot;
   if (pRootLayoutItem &&
       pRootLayoutItem->m_pFormNode->GetPacketID() == XFA_XDPPACKET_Form) {
     CXFA_Node* pPageSetFormNode = pRootLayoutItem->m_pFormNode;
     pRootLayoutItem->m_pFormNode->GetDocument()->m_pPendingPageSet.RemoveAll();
     if (pPageSetFormNode->HasRemovedChildren()) {
       XFA_ReleaseLayoutItem(pRootLayoutItem);
       m_pPageSetLayoutItemRoot = NULL;
       pRootLayoutItem = NULL;
       pPageSetFormNode = NULL;
       m_PageArray.RemoveAll();
     }
     while (pPageSetFormNode) {
       CXFA_Node* pNextPageSet =
-          pPageSetFormNode->GetNextSameClassSibling(XFA_ELEMENT_PageSet);
+          pPageSetFormNode->GetNextSameClassSibling(XFA_Element::PageSet);
       pPageSetFormNode->GetNodeItem(XFA_NODEITEM_Parent)
           ->RemoveChild(pPageSetFormNode, FALSE);
       pRootLayoutItem->m_pFormNode->GetDocument()->m_pPendingPageSet.Add(
           pPageSetFormNode);
       pPageSetFormNode = pNextPageSet;
     }
   }
   pRootLayoutItem = m_pPageSetLayoutItemRoot;
   CXFA_ContainerLayoutItem* pNextLayout = NULL;
   for (; pRootLayoutItem; pRootLayoutItem = pNextLayout) {
     pNextLayout = (CXFA_ContainerLayoutItem*)pRootLayoutItem->m_pNextSibling;
     SaveLayoutItem(pRootLayoutItem);
     delete pRootLayoutItem;
   }
   m_pPageSetLayoutItemRoot = NULL;
 }