Convert XFA_ELEMENT to an enum class

xfa/fxfa/parser/xfa_layout_itemlayout.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_itemlayout.h"
 
 #include <algorithm>
 #include <memory>
@@ skipping 55 matching lines @@
       m_fUsedSize(0),
       m_pPageMgr(pPageMgr),
       m_bBreakPending(TRUE),
       m_fLastRowWidth(0),
       m_fLastRowY(0),
       m_fWidthLimite(0),
       m_bUseInheriated(FALSE),
       m_ePreProcessRs(XFA_ItemLayoutProcessorResult_Done),
       m_bHasAvailHeight(TRUE) {
   ASSERT(m_pFormNode && (m_pFormNode->IsContainerNode() ||
-                         m_pFormNode->GetClassID() == XFA_ELEMENT_Form));
+                         m_pFormNode->GetClassID() == XFA_Element::Form));
   m_pOldLayoutItem =
       (CXFA_ContentLayoutItem*)m_pFormNode->GetUserData(XFA_LAYOUTITEMKEY);
 }
 
 CXFA_ItemLayoutProcessor::~CXFA_ItemLayoutProcessor() {}
 
 CXFA_ContentLayoutItem* CXFA_ItemLayoutProcessor::CreateContentLayoutItem(
     CXFA_Node* pFormNode) {
   if (!pFormNode) {
     return NULL;
@@ skipping 31 matching lines @@
   if (fProposedSplitPos > fCurVerticalOffset + XFA_LAYOUT_FLOAT_PERCISION &&
       fProposedSplitPos <= fCurVerticalOffset + pLayoutItem->m_sSize.y -
                                XFA_LAYOUT_FLOAT_PERCISION) {
     switch (pFormNode->GetIntact()) {
       case XFA_ATTRIBUTEENUM_None: {
         FX_BOOL bAnyChanged = FALSE;
         CXFA_Document* pDocument = pFormNode->GetDocument();
         CXFA_FFNotify* pNotify = pDocument->GetParser()->GetNotify();
         FX_FLOAT fCurTopMargin = 0, fCurBottomMargin = 0;
         CXFA_Node* pMarginNode =
-            pFormNode->GetFirstChildByClass(XFA_ELEMENT_Margin);
+            pFormNode->GetFirstChildByClass(XFA_Element::Margin);
         if (pMarginNode && bCalculateMargin) {
           fCurTopMargin = pMarginNode->GetMeasure(XFA_ATTRIBUTE_TopInset)
                               .ToUnit(XFA_UNIT_Pt);
           fCurBottomMargin = pMarginNode->GetMeasure(XFA_ATTRIBUTE_BottomInset)
                                  .ToUnit(XFA_UNIT_Pt);
         }
         FX_BOOL bChanged = TRUE;
         while (bChanged) {
           bChanged = FALSE;
           {
@@ skipping 54 matching lines @@
 }
 static XFA_ATTRIBUTEENUM XFA_ItemLayoutProcessor_GetLayout(
     CXFA_Node* pFormNode,
     FX_BOOL& bRootForceTb) {
   bRootForceTb = FALSE;
   XFA_ATTRIBUTEENUM eLayoutMode;
   if (pFormNode->TryEnum(XFA_ATTRIBUTE_Layout, eLayoutMode, FALSE)) {
     return eLayoutMode;
   }
   CXFA_Node* pParentNode = pFormNode->GetNodeItem(XFA_NODEITEM_Parent);
-  if (pParentNode && pParentNode->GetClassID() == XFA_ELEMENT_Form) {
+  if (pParentNode && pParentNode->GetClassID() == XFA_Element::Form) {
     bRootForceTb = TRUE;
     return XFA_ATTRIBUTEENUM_Tb;
   }
   return XFA_ATTRIBUTEENUM_Position;
 }
 static FX_BOOL XFA_ExistContainerKeep(CXFA_Node* pCurNode, FX_BOOL bPreFind) {
   if (pCurNode == NULL || !XFA_ItemLayoutProcessor_IsTakingSpace(pCurNode)) {
     return FALSE;
   }
   XFA_NODEITEM eItemType = XFA_NODEITEM_PrevSibling;
   if (!bPreFind) {
     eItemType = XFA_NODEITEM_NextSibling;
   }
   CXFA_Node* pPreContainer =
       pCurNode->GetNodeItem(eItemType, XFA_ObjectType::ContainerNode);
   if (pPreContainer == NULL) {
     return FALSE;
   }
-  CXFA_Node* pKeep = pCurNode->GetFirstChildByClass(XFA_ELEMENT_Keep);
+  CXFA_Node* pKeep = pCurNode->GetFirstChildByClass(XFA_Element::Keep);
   if (pKeep) {
     XFA_ATTRIBUTEENUM ePrevious;
     XFA_ATTRIBUTE eKeepType = XFA_ATTRIBUTE_Previous;
     if (!bPreFind) {
       eKeepType = XFA_ATTRIBUTE_Next;
     }
     if (pKeep->TryEnum(eKeepType, ePrevious, FALSE)) {
       if (ePrevious == XFA_ATTRIBUTEENUM_ContentArea ||
           ePrevious == XFA_ATTRIBUTEENUM_PageArea) {
         return TRUE;
       }
     }
   }
-  pKeep = pPreContainer->GetFirstChildByClass(XFA_ELEMENT_Keep);
+  pKeep = pPreContainer->GetFirstChildByClass(XFA_Element::Keep);
   if (!pKeep) {
     return FALSE;
   }
   XFA_ATTRIBUTEENUM eNext;
   XFA_ATTRIBUTE eKeepType = XFA_ATTRIBUTE_Next;
   if (!bPreFind) {
     eKeepType = XFA_ATTRIBUTE_Previous;
   }
   if (!pKeep->TryEnum(eKeepType, eNext, FALSE)) {
     return FALSE;
@@ skipping 24 matching lines @@
     CXFA_ContentLayoutItem* pLayoutItem,
     CXFA_ContentLayoutItem* pSecondParent,
     FX_FLOAT fSplitPos) {
   FX_FLOAT fCurTopMargin = 0, fCurBottomMargin = 0;
   XFA_ATTRIBUTEENUM eLayout = m_pFormNode->GetEnum(XFA_ATTRIBUTE_Layout);
   FX_BOOL bCalculateMargin = TRUE;
   if (eLayout == XFA_ATTRIBUTEENUM_Position) {
     bCalculateMargin = FALSE;
   }
   CXFA_Node* pMarginNode =
-      pLayoutItem->m_pFormNode->GetFirstChildByClass(XFA_ELEMENT_Margin);
+      pLayoutItem->m_pFormNode->GetFirstChildByClass(XFA_Element::Margin);
   if (pMarginNode && bCalculateMargin) {
     fCurTopMargin =
         pMarginNode->GetMeasure(XFA_ATTRIBUTE_TopInset).ToUnit(XFA_UNIT_Pt);
     fCurBottomMargin =
         pMarginNode->GetMeasure(XFA_ATTRIBUTE_BottomInset).ToUnit(XFA_UNIT_Pt);
   }
   CXFA_ContentLayoutItem* pSecondLayoutItem = NULL;
   if (m_pCurChildPreprocessor &&
       m_pCurChildPreprocessor->m_pFormNode == pLayoutItem->m_pFormNode) {
     pSecondLayoutItem = m_pCurChildPreprocessor->CreateContentLayoutItem(
@@ skipping 88 matching lines @@
   }
 }
 void CXFA_ItemLayoutProcessor::SplitLayoutItem(FX_FLOAT fSplitPos) {
   ASSERT(m_pLayoutItem);
   SplitLayoutItem(m_pLayoutItem, NULL, fSplitPos);
 }
 
 CXFA_ContainerLayoutItem* CXFA_LayoutItem::GetPage() const {
   for (CXFA_LayoutItem* pCurNode = const_cast<CXFA_LayoutItem*>(this); pCurNode;
        pCurNode = pCurNode->m_pParent) {
-    if (pCurNode->m_pFormNode->GetClassID() == XFA_ELEMENT_PageArea)
+    if (pCurNode->m_pFormNode->GetClassID() == XFA_Element::PageArea)
       return static_cast<CXFA_ContainerLayoutItem*>(pCurNode);
   }
   return nullptr;
 }
 
 CXFA_Node* CXFA_LayoutItem::GetFormNode() const {
   return m_pFormNode;
 }
 
 void CXFA_LayoutItem::GetRect(CFX_RectF& rtLayout, FX_BOOL bRelative) const {
   ASSERT(m_bIsContentLayoutItem);
   const CXFA_ContentLayoutItem* pThis =
       static_cast<const CXFA_ContentLayoutItem*>(this);
   CFX_PointF sPos = pThis->m_sPos;
   CFX_SizeF sSize = pThis->m_sSize;
   if (!bRelative) {
     for (CXFA_LayoutItem* pLayoutItem = pThis->m_pParent; pLayoutItem;
          pLayoutItem = pLayoutItem->m_pParent) {
       if (CXFA_ContentLayoutItem* pContent =
               pLayoutItem->AsContentLayoutItem()) {
         sPos += pContent->m_sPos;
         if (CXFA_Node* pMarginNode =
                 pLayoutItem->m_pFormNode->GetFirstChildByClass(
-                    XFA_ELEMENT_Margin)) {
+                    XFA_Element::Margin)) {
           sPos += CFX_PointF(pMarginNode->GetMeasure(XFA_ATTRIBUTE_LeftInset)
                                  .ToUnit(XFA_UNIT_Pt),
                              pMarginNode->GetMeasure(XFA_ATTRIBUTE_TopInset)
                                  .ToUnit(XFA_UNIT_Pt));
         }
       } else {
-        if (pLayoutItem->m_pFormNode->GetClassID() == XFA_ELEMENT_ContentArea) {
+        if (pLayoutItem->m_pFormNode->GetClassID() ==
+            XFA_Element::ContentArea) {
           sPos +=
               CFX_PointF(pLayoutItem->m_pFormNode->GetMeasure(XFA_ATTRIBUTE_X)
                              .ToUnit(XFA_UNIT_Pt),
                          pLayoutItem->m_pFormNode->GetMeasure(XFA_ATTRIBUTE_Y)
                              .ToUnit(XFA_UNIT_Pt));
           break;
         } else if (pLayoutItem->m_pFormNode->GetClassID() ==
-                   XFA_ELEMENT_PageArea) {
+                   XFA_Element::PageArea) {
           break;
         }
       }
     }
   }
   rtLayout.Set(sPos.x, sPos.y, sSize.x, sSize.y);
 }
 
 CXFA_LayoutItem* CXFA_LayoutItem::GetParent() const {
   return m_pParent;
@@ skipping 165 matching lines @@
     XFA_ItemLayoutProcessorStages& nCurStage,
     FX_BOOL bBreakBefore) {
   FX_BOOL bFindRs = FALSE;
   for (CXFA_Node* pBreakNode = pContainerNode; pBreakNode;
        pBreakNode = pBreakNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     XFA_ATTRIBUTE eAttributeType = XFA_ATTRIBUTE_Before;
     if (!bBreakBefore) {
       eAttributeType = XFA_ATTRIBUTE_After;
     }
     switch (pBreakNode->GetClassID()) {
-      case XFA_ELEMENT_BreakBefore: {
+      case XFA_Element::BreakBefore: {
         if (bBreakBefore) {
           pCurActionNode = pBreakNode;
           nCurStage = XFA_ItemLayoutProcessorStages_BreakBefore;
           bFindRs = TRUE;
         }
       } break;
-      case XFA_ELEMENT_BreakAfter: {
+      case XFA_Element::BreakAfter: {
         if (!bBreakBefore) {
           pCurActionNode = pBreakNode;
           nCurStage = XFA_ItemLayoutProcessorStages_BreakAfter;
           bFindRs = TRUE;
         }
       } break;
-      case XFA_ELEMENT_Break:
+      case XFA_Element::Break:
         if (pBreakNode->GetEnum(eAttributeType) != XFA_ATTRIBUTEENUM_Auto) {
           pCurActionNode = pBreakNode;
           nCurStage = XFA_ItemLayoutProcessorStages_BreakBefore;
           if (!bBreakBefore) {
             nCurStage = XFA_ItemLayoutProcessorStages_BreakAfter;
           }
           bFindRs = TRUE;
           break;
         }
       default:
@@ skipping 60 matching lines @@
     case XFA_ItemLayoutProcessorStages_None: {
       pCurActionNode = XFA_LAYOUT_INVALIDNODE;
       case XFA_ItemLayoutProcessorStages_BookendLeader:
         for (CXFA_Node* pBookendNode =
                  pCurActionNode == XFA_LAYOUT_INVALIDNODE
                      ? pEntireContainer->GetNodeItem(XFA_NODEITEM_FirstChild)
                      : pCurActionNode->GetNodeItem(XFA_NODEITEM_NextSibling);
              pBookendNode; pBookendNode = pBookendNode->GetNodeItem(
                                XFA_NODEITEM_NextSibling)) {
           switch (pBookendNode->GetClassID()) {
-            case XFA_ELEMENT_Bookend:
-            case XFA_ELEMENT_Break:
+            case XFA_Element::Bookend:
+            case XFA_Element::Break:
               pCurActionNode = pBookendNode;
               nCurStage = XFA_ItemLayoutProcessorStages_BookendLeader;
               return;
             default:
               break;
           }
         }
     }
       {
         pCurActionNode = XFA_LAYOUT_INVALIDNODE;
@@ skipping 81 matching lines @@
     NoMoreChildContainer : {
       pCurActionNode = XFA_LAYOUT_INVALIDNODE;
       case XFA_ItemLayoutProcessorStages_BookendTrailer:
         for (CXFA_Node* pBookendNode =
                  pCurActionNode == XFA_LAYOUT_INVALIDNODE
                      ? pEntireContainer->GetNodeItem(XFA_NODEITEM_FirstChild)
                      : pCurActionNode->GetNodeItem(XFA_NODEITEM_NextSibling);
              pBookendNode; pBookendNode = pBookendNode->GetNodeItem(
                                XFA_NODEITEM_NextSibling)) {
           switch (pBookendNode->GetClassID()) {
-            case XFA_ELEMENT_Bookend:
-            case XFA_ELEMENT_Break:
+            case XFA_Element::Bookend:
+            case XFA_Element::Break:
               pCurActionNode = pBookendNode;
               nCurStage = XFA_ItemLayoutProcessorStages_BookendTrailer;
               return;
             default:
               break;
           }
         }
     }
     default:
       pCurActionNode = NULL;
@@ skipping 68 matching lines @@
 static inline void XFA_ItemLayoutProcessor_CalculateContainerSpecfiedSize(
     CXFA_Node* pFormNode,
     FX_FLOAT& fContainerWidth,
     FX_FLOAT& fContainerHeight,
     FX_BOOL& bContainerWidthAutoSize,
     FX_BOOL& bContainerHeightAutoSize) {
   fContainerWidth = 0;
   fContainerHeight = 0;
   bContainerWidthAutoSize = TRUE;
   bContainerHeightAutoSize = TRUE;
-  XFA_ELEMENT eClassID = pFormNode->GetClassID();
+  XFA_Element eClassID = pFormNode->GetClassID();
   CXFA_Measurement mTmpValue;
-  if (bContainerWidthAutoSize &&
-      (eClassID == XFA_ELEMENT_Subform || eClassID == XFA_ELEMENT_ExclGroup) &&
+  if (bContainerWidthAutoSize && (eClassID == XFA_Element::Subform ||
+                                  eClassID == XFA_Element::ExclGroup) &&
       pFormNode->TryMeasure(XFA_ATTRIBUTE_W, mTmpValue, FALSE) &&
       mTmpValue.GetValue() > XFA_LAYOUT_FLOAT_PERCISION) {
     fContainerWidth = mTmpValue.ToUnit(XFA_UNIT_Pt);
     bContainerWidthAutoSize = FALSE;
   }
-  if (bContainerHeightAutoSize &&
-      (eClassID == XFA_ELEMENT_Subform || eClassID == XFA_ELEMENT_ExclGroup) &&
+  if (bContainerHeightAutoSize && (eClassID == XFA_Element::Subform ||
+                                   eClassID == XFA_Element::ExclGroup) &&
       pFormNode->TryMeasure(XFA_ATTRIBUTE_H, mTmpValue, FALSE) &&
       mTmpValue.GetValue() > XFA_LAYOUT_FLOAT_PERCISION) {
     fContainerHeight = mTmpValue.ToUnit(XFA_UNIT_Pt);
     bContainerHeightAutoSize = FALSE;
   }
-  if (bContainerWidthAutoSize && eClassID == XFA_ELEMENT_Subform &&
+  if (bContainerWidthAutoSize && eClassID == XFA_Element::Subform &&
       pFormNode->TryMeasure(XFA_ATTRIBUTE_MaxW, mTmpValue, FALSE) &&
       mTmpValue.GetValue() > XFA_LAYOUT_FLOAT_PERCISION) {
     fContainerWidth = mTmpValue.ToUnit(XFA_UNIT_Pt);
     bContainerWidthAutoSize = FALSE;
   }
-  if (bContainerHeightAutoSize && eClassID == XFA_ELEMENT_Subform &&
+  if (bContainerHeightAutoSize && eClassID == XFA_Element::Subform &&
       pFormNode->TryMeasure(XFA_ATTRIBUTE_MaxH, mTmpValue, FALSE) &&
       mTmpValue.GetValue() > XFA_LAYOUT_FLOAT_PERCISION) {
     fContainerHeight = mTmpValue.ToUnit(XFA_UNIT_Pt);
     bContainerHeightAutoSize = FALSE;
   }
 }
 static inline void
 XFA_ItemLayoutProcessor_CalculateContainerComponentSizeFromContentSize(
     CXFA_Node* pFormNode,
     FX_BOOL bContainerWidthAutoSize,
     FX_FLOAT fContentCalculatedWidth,
     FX_FLOAT& fContainerWidth,
     FX_BOOL bContainerHeightAutoSize,
     FX_FLOAT fContentCalculatedHeight,
     FX_FLOAT& fContainerHeight) {
-  CXFA_Node* pMarginNode = pFormNode->GetFirstChildByClass(XFA_ELEMENT_Margin);
+  CXFA_Node* pMarginNode = pFormNode->GetFirstChildByClass(XFA_Element::Margin);
   CXFA_Measurement mTmpValue;
   if (bContainerWidthAutoSize) {
     fContainerWidth = fContentCalculatedWidth;
     if (pMarginNode) {
       if (pMarginNode->TryMeasure(XFA_ATTRIBUTE_LeftInset, mTmpValue, FALSE)) {
         fContainerWidth += mTmpValue.ToUnit(XFA_UNIT_Pt);
       }
       if (pMarginNode->TryMeasure(XFA_ATTRIBUTE_RightInset, mTmpValue, FALSE)) {
         fContainerWidth += mTmpValue.ToUnit(XFA_UNIT_Pt);
       }
@@ skipping 98 matching lines @@
   XFA_ItemLayoutProcessorStages nCurChildNodeStage =
       XFA_ItemLayoutProcessorStages_None;
   CXFA_LayoutItem* pBeforeItem = NULL;
   for (XFA_ItemLayoutProcessor_GotoNextContainerNode(
            pCurChildNode, nCurChildNodeStage, pFormNode, FALSE);
        pCurChildNode; XFA_ItemLayoutProcessor_GotoNextContainerNode(
            pCurChildNode, nCurChildNodeStage, pFormNode, FALSE)) {
     if (nCurChildNodeStage != XFA_ItemLayoutProcessorStages_Container) {
       continue;
     }
-    if (pCurChildNode->GetClassID() == XFA_ELEMENT_Variables) {
+    if (pCurChildNode->GetClassID() == XFA_Element::Variables) {
       continue;
     }
     CXFA_ItemLayoutProcessor* pProcessor =
         new CXFA_ItemLayoutProcessor(pCurChildNode, NULL);
     pProcessor->DoLayout(FALSE, XFA_LAYOUT_FLOAT_MAX);
     if (!pProcessor->HasLayoutItem()) {
       delete pProcessor;
       continue;
     }
     FX_FLOAT fWidth, fHeight;
     pProcessor->GetCurrentComponentSize(fWidth, fHeight);
     FX_FLOAT fAbsoluteX = 0, fAbsoluteY = 0;
     CalculatePositionedContainerPos(pCurChildNode, fWidth, fHeight, fAbsoluteX,
                                     fAbsoluteY);
     pProcessor->SetCurrentComponentPos(fAbsoluteX, fAbsoluteY);
     CXFA_LayoutItem* pProcessItem = pProcessor->ExtractLayoutItem();
     if (pBeforeItem == NULL) {
       pPageAreaLayoutItem->AddHeadChild(pProcessItem);
     } else {
       pPageAreaLayoutItem->InsertChild(pBeforeItem, pProcessItem);
     }
     pBeforeItem = pProcessItem;
     delete pProcessor;
   }
   pBeforeItem = NULL;
   CXFA_LayoutItem* pLayoutItem = pPageAreaLayoutItem->m_pFirstChild;
   while (pLayoutItem) {
     if (!pLayoutItem->IsContentLayoutItem() ||
-        pLayoutItem->m_pFormNode->GetClassID() != XFA_ELEMENT_Draw) {
+        pLayoutItem->m_pFormNode->GetClassID() != XFA_Element::Draw) {
       pLayoutItem = pLayoutItem->m_pNextSibling;
       continue;
     }
-    if (pLayoutItem->m_pFormNode->GetClassID() == XFA_ELEMENT_Draw) {
+    if (pLayoutItem->m_pFormNode->GetClassID() == XFA_Element::Draw) {
       CXFA_LayoutItem* pNextLayoutItem = pLayoutItem->m_pNextSibling;
       pPageAreaLayoutItem->RemoveChild(pLayoutItem);
       if (pBeforeItem == NULL) {
         pPageAreaLayoutItem->AddHeadChild(pLayoutItem);
       } else {
         pPageAreaLayoutItem->InsertChild(pBeforeItem, pLayoutItem);
       }
       pBeforeItem = pLayoutItem;
       pLayoutItem = pNextLayoutItem;
     }
@@ skipping 18 matching lines @@
   if (m_pCurChildNode == XFA_LAYOUT_INVALIDNODE) {
     XFA_ItemLayoutProcessor_GotoNextContainerNode(
         m_pCurChildNode, m_nCurChildNodeStage, m_pFormNode, FALSE);
   }
   int32_t iColIndex = 0;
   for (; m_pCurChildNode; XFA_ItemLayoutProcessor_GotoNextContainerNode(
            m_pCurChildNode, m_nCurChildNodeStage, m_pFormNode, FALSE)) {
     if (m_nCurChildNodeStage != XFA_ItemLayoutProcessorStages_Container) {
       continue;
     }
-    if (m_pCurChildNode->GetClassID() == XFA_ELEMENT_Variables) {
+    if (m_pCurChildNode->GetClassID() == XFA_Element::Variables) {
       continue;
     }
     CXFA_ItemLayoutProcessor* pProcessor =
         new CXFA_ItemLayoutProcessor(m_pCurChildNode, m_pPageMgr);
     if (pContext && pContext->m_prgSpecifiedColumnWidths) {
       int32_t iColSpan = m_pCurChildNode->GetInteger(XFA_ATTRIBUTE_ColSpan);
       if (iColSpan <=
           pContext->m_prgSpecifiedColumnWidths->GetSize() - iColIndex) {
         pContext->m_fCurColumnWidth = 0;
         pContext->m_bCurColumnWidthAvaiable = TRUE;
@@ skipping 27 matching lines @@
     }
     pProcessor->SetCurrentComponentPos(fAbsoluteX, fAbsoluteY);
     if (bContainerWidthAutoSize) {
       FX_FLOAT fChildSuppliedWidth = fAbsoluteX + fWidth;
       if (bChangeParentSize) {
         if (fContentCalculatedWidth < fChildSuppliedWidth) {
           fContentCalculatedWidth = fChildSuppliedWidth;
         }
       } else {
         if (fHiddenContentCalculatedWidth < fChildSuppliedWidth &&
-            m_pCurChildNode->GetClassID() != XFA_ELEMENT_Subform) {
+            m_pCurChildNode->GetClassID() != XFA_Element::Subform) {
           fHiddenContentCalculatedWidth = fChildSuppliedWidth;
         }
       }
     }
     if (bContainerHeightAutoSize) {
       FX_FLOAT fChildSuppliedHeight = fAbsoluteY + fHeight;
       if (bChangeParentSize) {
         if (fContentCalculatedHeight < fChildSuppliedHeight) {
           fContentCalculatedHeight = fChildSuppliedHeight;
         }
       } else {
         if (fHiddenContentCalculatedHeight < fChildSuppliedHeight &&
-            m_pCurChildNode->GetClassID() != XFA_ELEMENT_Subform) {
+            m_pCurChildNode->GetClassID() != XFA_Element::Subform) {
           fHiddenContentCalculatedHeight = fChildSuppliedHeight;
         }
       }
     }
     m_pLayoutItem->AddChild(pProcessor->ExtractLayoutItem());
     delete pProcessor;
   }
   XFA_VERSION eVersion = m_pFormNode->GetDocument()->GetCurVersionMode();
   if (fContentCalculatedWidth == 0 && eVersion < XFA_VERSION_207) {
     fContentCalculatedWidth = fHiddenContentCalculatedWidth;
   }
   if (fContentCalculatedHeight == 0 && eVersion < XFA_VERSION_207) {
     fContentCalculatedHeight = fHiddenContentCalculatedHeight;
   }
   XFA_ItemLayoutProcessor_CalculateContainerComponentSizeFromContentSize(
       m_pFormNode, bContainerWidthAutoSize, fContentCalculatedWidth,
       fContainerWidth, bContainerHeightAutoSize, fContentCalculatedHeight,
       fContainerHeight);
   SetCurrentComponentSize(fContainerWidth, fContainerHeight);
 }
 static inline void XFA_ItemLayoutProcessor_UpdateWidgetSize(
     CXFA_ContentLayoutItem* pLayoutItem,
     FX_FLOAT& fWidth,
     FX_FLOAT& fHeight) {
   CXFA_Node* pNode = pLayoutItem->m_pFormNode;
   ASSERT(pNode);
-  XFA_ELEMENT eClassID = pNode->GetClassID();
+  XFA_Element eClassID = pNode->GetClassID();
   switch (eClassID) {
-    case XFA_ELEMENT_Subform:
-    case XFA_ELEMENT_Area:
-    case XFA_ELEMENT_ExclGroup:
-    case XFA_ELEMENT_SubformSet: {
+    case XFA_Element::Subform:
+    case XFA_Element::Area:
+    case XFA_Element::ExclGroup:
+    case XFA_Element::SubformSet: {
       if (fWidth < -XFA_LAYOUT_FLOAT_PERCISION) {
         fWidth = pLayoutItem->m_sSize.x;
       }
       if (fHeight < -XFA_LAYOUT_FLOAT_PERCISION) {
         fHeight = pLayoutItem->m_sSize.y;
       }
       break;
     }
-    case XFA_ELEMENT_Draw:
-    case XFA_ELEMENT_Field: {
+    case XFA_Element::Draw:
+    case XFA_Element::Field: {
       pNode->GetDocument()->GetParser()->GetNotify()->StartFieldDrawLayout(
           pNode, fWidth, fHeight);
       break;
     }
     default:
       ASSERT(FALSE);
   }
 }
 static inline void XFA_ItemLayoutProcessor_RelocateTableRowCells(
     CXFA_ContentLayoutItem* pLayoutRow,
     const CFX_ArrayTemplate<FX_FLOAT>& rgSpecifiedColumnWidths,
     XFA_ATTRIBUTEENUM eLayout) {
   FX_FLOAT fContainerWidth = 0, fContainerHeight = 0;
   FX_BOOL bContainerWidthAutoSize = TRUE, bContainerHeightAutoSize = TRUE;
   XFA_ItemLayoutProcessor_CalculateContainerSpecfiedSize(
       pLayoutRow->m_pFormNode, fContainerWidth, fContainerHeight,
       bContainerWidthAutoSize, bContainerHeightAutoSize);
   CXFA_Node* pMarginNode =
-      pLayoutRow->m_pFormNode->GetFirstChildByClass(XFA_ELEMENT_Margin);
+      pLayoutRow->m_pFormNode->GetFirstChildByClass(XFA_Element::Margin);
   FX_FLOAT fLeftInset = 0, fTopInset = 0, fRightInset = 0, fBottomInset = 0;
   if (pMarginNode) {
     fLeftInset =
         pMarginNode->GetMeasure(XFA_ATTRIBUTE_LeftInset).ToUnit(XFA_UNIT_Pt);
     fTopInset =
         pMarginNode->GetMeasure(XFA_ATTRIBUTE_TopInset).ToUnit(XFA_UNIT_Pt);
     fRightInset =
         pMarginNode->GetMeasure(XFA_ATTRIBUTE_RightInset).ToUnit(XFA_UNIT_Pt);
     fBottomInset =
         pMarginNode->GetMeasure(XFA_ATTRIBUTE_BottomInset).ToUnit(XFA_UNIT_Pt);
@@ skipping 50 matching lines @@
   if (bContainerHeightAutoSize) {
     for (CXFA_ContentLayoutItem* pLayoutChild =
              (CXFA_ContentLayoutItem*)pLayoutRow->m_pFirstChild;
          pLayoutChild;
          pLayoutChild = (CXFA_ContentLayoutItem*)pLayoutChild->m_pNextSibling) {
       XFA_ItemLayoutProcessor_UpdateWidgetSize(
           pLayoutChild, pLayoutChild->m_sSize.x, fContentCalculatedHeight);
       FX_FLOAT fOldChildHeight = pLayoutChild->m_sSize.y;
       pLayoutChild->m_sSize.y = fContentCalculatedHeight;
       CXFA_Node* pParaNode =
-          pLayoutChild->m_pFormNode->GetFirstChildByClass(XFA_ELEMENT_Para);
+          pLayoutChild->m_pFormNode->GetFirstChildByClass(XFA_Element::Para);
       if (pParaNode && pLayoutChild->m_pFirstChild) {
         FX_FLOAT fOffHeight = fContentCalculatedHeight - fOldChildHeight;
         XFA_ATTRIBUTEENUM eVType = pParaNode->GetEnum(XFA_ATTRIBUTE_VAlign);
         switch (eVType) {
           case XFA_ATTRIBUTEENUM_Middle:
             fOffHeight = fOffHeight / 2;
             break;
           case XFA_ATTRIBUTEENUM_Bottom:
             break;
           case XFA_ATTRIBUTEENUM_Top:
@@ skipping 50 matching lines @@
   }
   ASSERT(m_pCurChildNode == XFA_LAYOUT_INVALIDNODE);
   m_pLayoutItem = CreateContentLayoutItem(m_pFormNode);
   FX_FLOAT fContainerWidth = 0, fContainerHeight = 0;
   FX_BOOL bContainerWidthAutoSize = TRUE, bContainerHeightAutoSize = TRUE;
   XFA_ItemLayoutProcessor_CalculateContainerSpecfiedSize(
       m_pFormNode, fContainerWidth, fContainerHeight, bContainerWidthAutoSize,
       bContainerHeightAutoSize);
   FX_FLOAT fContentCalculatedWidth = 0, fContentCalculatedHeight = 0;
   CXFA_Node* pMarginNode =
-      m_pFormNode->GetFirstChildByClass(XFA_ELEMENT_Margin);
+      m_pFormNode->GetFirstChildByClass(XFA_Element::Margin);
   FX_FLOAT fLeftInset = 0;
   FX_FLOAT fRightInset = 0;
   if (pMarginNode) {
     fLeftInset =
         pMarginNode->GetMeasure(XFA_ATTRIBUTE_LeftInset).ToUnit(XFA_UNIT_Pt);
     fRightInset =
         pMarginNode->GetMeasure(XFA_ATTRIBUTE_RightInset).ToUnit(XFA_UNIT_Pt);
   }
   FX_FLOAT fContentWidthLimit =
       bContainerWidthAutoSize ? XFA_LAYOUT_FLOAT_MAX
@@ skipping 44 matching lines @@
   }
   int32_t iRowCount = 0, iColCount = 0;
   {
     CFX_ArrayTemplate<CXFA_ContentLayoutItem*> rgRowItems;
     CFX_ArrayTemplate<int32_t> rgRowItemsSpan;
     CFX_ArrayTemplate<FX_FLOAT> rgRowItemsWidth;
     for (CXFA_ContentLayoutItem* pLayoutChild =
              (CXFA_ContentLayoutItem*)m_pLayoutItem->m_pFirstChild;
          pLayoutChild;
          pLayoutChild = (CXFA_ContentLayoutItem*)pLayoutChild->m_pNextSibling) {
-      if (pLayoutChild->m_pFormNode->GetClassID() != XFA_ELEMENT_Subform) {
+      if (pLayoutChild->m_pFormNode->GetClassID() != XFA_Element::Subform) {
         continue;
       }
       if (!XFA_ItemLayoutProcessor_IsTakingSpace(pLayoutChild->m_pFormNode)) {
         continue;
       }
       XFA_ATTRIBUTEENUM eLayout =
           pLayoutChild->m_pFormNode->GetEnum(XFA_ATTRIBUTE_Layout);
       if (eLayout != XFA_ATTRIBUTEENUM_Row &&
           eLayout != XFA_ATTRIBUTEENUM_Rl_row) {
         continue;
@@ skipping 68 matching lines @@
     }
   }
   FX_FLOAT fCurrentRowY = 0;
   for (CXFA_ContentLayoutItem* pLayoutChild =
            (CXFA_ContentLayoutItem*)m_pLayoutItem->m_pFirstChild;
        pLayoutChild;
        pLayoutChild = (CXFA_ContentLayoutItem*)pLayoutChild->m_pNextSibling) {
     if (!XFA_ItemLayoutProcessor_IsTakingSpace(pLayoutChild->m_pFormNode)) {
       continue;
     }
-    if (pLayoutChild->m_pFormNode->GetClassID() == XFA_ELEMENT_Subform) {
+    if (pLayoutChild->m_pFormNode->GetClassID() == XFA_Element::Subform) {
       XFA_ATTRIBUTEENUM eSubformLayout =
           pLayoutChild->m_pFormNode->GetEnum(XFA_ATTRIBUTE_Layout);
       if (eSubformLayout == XFA_ATTRIBUTEENUM_Row ||
           eSubformLayout == XFA_ATTRIBUTEENUM_Rl_row) {
         XFA_ItemLayoutProcessor_RelocateTableRowCells(
             pLayoutChild, m_rgSpecifiedColumnWidths, eSubformLayout);
       }
     }
     pLayoutChild->m_sPos.y = fCurrentRowY;
     if (bContainerWidthAutoSize) {
@@ skipping 92 matching lines @@
       fNewSplitPos = pProcessor->FindSplitPos(fSplitPos - fHeight);
     }
     if (fNewSplitPos > XFA_LAYOUT_FLOAT_PERCISION) {
       pProcessor->SplitLayoutItem(fNewSplitPos);
     }
     return;
   }
   XFA_ItemLayoutProcessor_UpdatePendedItemLayout(pProcessor,
                                                  pTrailerLayoutItem);
   CXFA_Node* pMarginNode =
-      pProcessor->m_pFormNode->GetFirstChildByClass(XFA_ELEMENT_Margin);
+      pProcessor->m_pFormNode->GetFirstChildByClass(XFA_Element::Margin);
   FX_FLOAT fLeftInset = 0, fTopInset = 0, fRightInset = 0, fBottomInset = 0;
   if (pMarginNode) {
     fLeftInset =
         pMarginNode->GetMeasure(XFA_ATTRIBUTE_LeftInset).ToUnit(XFA_UNIT_Pt);
     fTopInset =
         pMarginNode->GetMeasure(XFA_ATTRIBUTE_TopInset).ToUnit(XFA_UNIT_Pt);
     fRightInset =
         pMarginNode->GetMeasure(XFA_ATTRIBUTE_RightInset).ToUnit(XFA_UNIT_Pt);
     fBottomInset =
         pMarginNode->GetMeasure(XFA_ATTRIBUTE_BottomInset).ToUnit(XFA_UNIT_Pt);
@@ skipping 33 matching lines @@
       break;
   }
   pProcessor->m_pLayoutItem->m_sSize.y += fHeight;
   pProcessor->m_pLayoutItem->AddChild(pTrailerLayoutItem);
 }
 static void XFA_ItemLayoutProcessor_AddLeaderAfterSplit(
     CXFA_ItemLayoutProcessor* pProcessor,
     CXFA_ContentLayoutItem* pLeaderLayoutItem) {
   XFA_ItemLayoutProcessor_UpdatePendedItemLayout(pProcessor, pLeaderLayoutItem);
   CXFA_Node* pMarginNode =
-      pProcessor->m_pFormNode->GetFirstChildByClass(XFA_ELEMENT_Margin);
+      pProcessor->m_pFormNode->GetFirstChildByClass(XFA_Element::Margin);
   FX_FLOAT fLeftInset = 0;
   FX_FLOAT fRightInset = 0;
   if (pMarginNode) {
     fLeftInset =
         pMarginNode->GetMeasure(XFA_ATTRIBUTE_LeftInset).ToUnit(XFA_UNIT_Pt);
     fRightInset =
         pMarginNode->GetMeasure(XFA_ATTRIBUTE_RightInset).ToUnit(XFA_UNIT_Pt);
   }
   FX_FLOAT fHeight = pLeaderLayoutItem->m_sSize.y;
   for (CXFA_ContentLayoutItem* pChildItem =
@@ skipping 173 matching lines @@
 void CXFA_ItemLayoutProcessor::ProcessUnUseOverFlow(
     CXFA_Node* pLeaderNode,
     CXFA_Node* pTrailerNode,
     CXFA_ContentLayoutItem* pTrailerItem,
     CXFA_Node* pFormNode) {
   ProcessUnUseBinds(pLeaderNode);
   ProcessUnUseBinds(pTrailerNode);
   if (pFormNode == NULL) {
     return;
   }
-  if (pFormNode->GetClassID() == XFA_ELEMENT_Overflow ||
-      pFormNode->GetClassID() == XFA_ELEMENT_Break) {
+  if (pFormNode->GetClassID() == XFA_Element::Overflow ||
+      pFormNode->GetClassID() == XFA_Element::Break) {
     pFormNode = pFormNode->GetNodeItem(XFA_NODEITEM_Parent);
   }
   if (pLeaderNode && pFormNode) {
     pFormNode->RemoveChild(pLeaderNode);
   }
   if (pTrailerNode && pFormNode) {
     pFormNode->RemoveChild(pTrailerNode);
   }
   if (pTrailerItem) {
     XFA_ReleaseLayoutItem(pTrailerItem);
@@ skipping 382 matching lines @@
           XFA_NODEITEM_FirstChild, XFA_ObjectType::ContainerNode);
       if (pChildContainer &&
           pChildContainer->GetNodeItem(XFA_NODEITEM_NextSibling,
                                        XFA_ObjectType::ContainerNode)) {
         fContainerHeight = 0;
         bContainerHeightAutoSize = TRUE;
       }
     }
   }
   CXFA_Node* pMarginNode =
-      m_pFormNode->GetFirstChildByClass(XFA_ELEMENT_Margin);
+      m_pFormNode->GetFirstChildByClass(XFA_Element::Margin);
   FX_FLOAT fLeftInset = 0, fTopInset = 0, fRightInset = 0, fBottomInset = 0;
   if (pMarginNode) {
     fLeftInset =
         pMarginNode->GetMeasure(XFA_ATTRIBUTE_LeftInset).ToUnit(XFA_UNIT_Pt);
     fTopInset =
         pMarginNode->GetMeasure(XFA_ATTRIBUTE_TopInset).ToUnit(XFA_UNIT_Pt);
     fRightInset =
         pMarginNode->GetMeasure(XFA_ATTRIBUTE_RightInset).ToUnit(XFA_UNIT_Pt);
     fBottomInset =
         pMarginNode->GetMeasure(XFA_ATTRIBUTE_BottomInset).ToUnit(XFA_UNIT_Pt);
@@ skipping 135 matching lines @@
             CXFA_ContentLayoutItem* pItem = m_arrayKeepItems.GetAt(iIndex);
             m_pLayoutItem->RemoveChild(pItem);
             fContentCalculatedHeight -= pItem->m_sSize.y;
           }
           CXFA_Node *pLeaderNode = NULL, *pTrailerNode = NULL;
           FX_BOOL bCreatePage = FALSE;
           if (bUseBreakControl && m_pPageMgr &&
               m_pPageMgr->ProcessBreakBeforeOrAfter(m_pCurChildNode, TRUE,
                                                     pLeaderNode, pTrailerNode,
                                                     bCreatePage) &&
-              m_pFormNode->GetClassID() != XFA_ELEMENT_Form && bCreatePage) {
+              m_pFormNode->GetClassID() != XFA_Element::Form && bCreatePage) {
             if (JudgeLeaderOrTrailerForOccur(pLeaderNode)) {
               XFA_ItemLayoutProcessor_AddPendingNode(this, pLeaderNode, TRUE);
             }
             if (JudgeLeaderOrTrailerForOccur(pTrailerNode)) {
               if (m_pFormNode->GetNodeItem(XFA_NODEITEM_Parent)->GetClassID() ==
-                      XFA_ELEMENT_Form &&
+                      XFA_Element::Form &&
                   m_pLayoutItem == NULL) {
                 XFA_ItemLayoutProcessor_AddPendingNode(this, pTrailerNode,
                                                        TRUE);
               } else {
                 std::unique_ptr<CXFA_ItemLayoutProcessor> pTempProcessor(
                     new CXFA_ItemLayoutProcessor(pTrailerNode, nullptr));
                 XFA_ItemLayoutProcessor_InsertFlowedItem(
                     this, pTempProcessor.get(), bContainerWidthAutoSize,
                     bContainerHeightAutoSize, fContainerHeight, eFlowStrategy,
                     uCurHAlignState, rgCurLineLayoutItems, FALSE,
@@ skipping 10 matching lines @@
             goto SuspendAndCreateNewRow;
           }
         } break;
         case XFA_ItemLayoutProcessorStages_BreakAfter: {
           CXFA_Node *pLeaderNode = NULL, *pTrailerNode = NULL;
           FX_BOOL bCreatePage = FALSE;
           if (bUseBreakControl && m_pPageMgr &&
               m_pPageMgr->ProcessBreakBeforeOrAfter(m_pCurChildNode, FALSE,
                                                     pLeaderNode, pTrailerNode,
                                                     bCreatePage) &&
-              m_pFormNode->GetClassID() != XFA_ELEMENT_Form) {
+              m_pFormNode->GetClassID() != XFA_Element::Form) {
             if (JudgeLeaderOrTrailerForOccur(pTrailerNode)) {
               std::unique_ptr<CXFA_ItemLayoutProcessor> pTempProcessor(
                   new CXFA_ItemLayoutProcessor(pTrailerNode, nullptr));
               XFA_ItemLayoutProcessor_InsertFlowedItem(
                   this, pTempProcessor.get(), bContainerWidthAutoSize,
                   bContainerHeightAutoSize, fContainerHeight, eFlowStrategy,
                   uCurHAlignState, rgCurLineLayoutItems, FALSE,
                   XFA_LAYOUT_FLOAT_MAX, XFA_LAYOUT_FLOAT_MAX, fContentCurRowY,
                   fContentWidthLimit, fContentCurRowAvailWidth,
                   fContentCurRowHeight, bAddedItemInRow, bForceEndPage,
@@ skipping 82 matching lines @@
                     pContext) != XFA_ItemLayoutProcessorResult_Done) {
               goto SuspendAndCreateNewRow;
             } else {
               delete pProcessor;
               pProcessor = NULL;
             }
           }
         } break;
         case XFA_ItemLayoutProcessorStages_Container:
           ASSERT(m_pCurChildNode->IsContainerNode());
-          if (m_pCurChildNode->GetClassID() == XFA_ELEMENT_Variables) {
+          if (m_pCurChildNode->GetClassID() == XFA_Element::Variables) {
             break;
           }
           if (fContentCurRowY >= fHeightLimit + XFA_LAYOUT_FLOAT_PERCISION &&
               XFA_ItemLayoutProcessor_IsTakingSpace(m_pCurChildNode)) {
             bForceEndPage = TRUE;
             goto SuspendAndCreateNewRow;
           }
           if (m_pCurChildNode->IsContainerNode()) {
             FX_BOOL bNewRow = FALSE;
             if (m_pCurChildPreprocessor) {
@@ skipping 240 matching lines @@
   if (bContainerHeightAutoSize) {
     FX_FLOAT fChildSuppliedHeight = fContentCurRowY;
     if (fContentCalculatedHeight < fChildSuppliedHeight) {
       fContentCalculatedHeight = fChildSuppliedHeight;
     }
   }
   return TRUE;
 }
 CXFA_Node* CXFA_ItemLayoutProcessor::GetSubformSetParent(
     CXFA_Node* pSubformSet) {
-  if (pSubformSet && pSubformSet->GetClassID() == XFA_ELEMENT_SubformSet) {
+  if (pSubformSet && pSubformSet->GetClassID() == XFA_Element::SubformSet) {
     CXFA_Node* pParent = pSubformSet->GetNodeItem(XFA_NODEITEM_Parent);
     while (pParent) {
-      if (pParent->GetClassID() != XFA_ELEMENT_SubformSet) {
+      if (pParent->GetClassID() != XFA_Element::SubformSet) {
         return pParent;
       }
       pParent = pParent->GetNodeItem(XFA_NODEITEM_Parent);
     }
   }
   return pSubformSet;
 }
 void CXFA_ItemLayoutProcessor::DoLayoutField() {
   if (m_pLayoutItem)
     return;
@@ skipping 16 matching lines @@
     fWidth = fHeight;
     fHeight = fTmp;
   }
   SetCurrentComponentSize(fWidth, fHeight);
 }
 XFA_ItemLayoutProcessorResult CXFA_ItemLayoutProcessor::DoLayout(
     FX_BOOL bUseBreakControl,
     FX_FLOAT fHeightLimit,
     FX_FLOAT fRealHeight,
     CXFA_LayoutContext* pContext) {
-  XFA_ELEMENT eClassID = m_pFormNode->GetClassID();
+  XFA_Element eClassID = m_pFormNode->GetClassID();
   switch (eClassID) {
-    case XFA_ELEMENT_Subform:
-    case XFA_ELEMENT_Area:
-    case XFA_ELEMENT_ExclGroup:
-    case XFA_ELEMENT_SubformSet: {
+    case XFA_Element::Subform:
+    case XFA_Element::Area:
+    case XFA_Element::ExclGroup:
+    case XFA_Element::SubformSet: {
       FX_BOOL bRootForceTb = FALSE;
       CXFA_Node* pLayoutNode = GetSubformSetParent(m_pFormNode);
       XFA_ATTRIBUTEENUM eLayoutStrategy =
           XFA_ItemLayoutProcessor_GetLayout(pLayoutNode, bRootForceTb);
       switch (eLayoutStrategy) {
         case XFA_ATTRIBUTEENUM_Tb:
         case XFA_ATTRIBUTEENUM_Lr_tb:
         case XFA_ATTRIBUTEENUM_Rl_tb:
           return DoLayoutFlowedContainer(bUseBreakControl, eLayoutStrategy,
                                          fHeightLimit, fRealHeight, pContext,
                                          bRootForceTb);
         case XFA_ATTRIBUTEENUM_Position:
         case XFA_ATTRIBUTEENUM_Row:
         case XFA_ATTRIBUTEENUM_Rl_row:
         default:
           DoLayoutPositionedContainer(pContext);
           m_nCurChildNodeStage = XFA_ItemLayoutProcessorStages_Done;
           return XFA_ItemLayoutProcessorResult_Done;
         case XFA_ATTRIBUTEENUM_Table:
           DoLayoutTableContainer(pLayoutNode);
           m_nCurChildNodeStage = XFA_ItemLayoutProcessorStages_Done;
           return XFA_ItemLayoutProcessorResult_Done;
       }
     }
-    case XFA_ELEMENT_Draw:
-    case XFA_ELEMENT_Field:
+    case XFA_Element::Draw:
+    case XFA_Element::Field:
       DoLayoutField();
       m_nCurChildNodeStage = XFA_ItemLayoutProcessorStages_Done;
       return XFA_ItemLayoutProcessorResult_Done;
-    case XFA_ELEMENT_ContentArea:
+    case XFA_Element::ContentArea:
       return XFA_ItemLayoutProcessorResult_Done;
     default:
       return XFA_ItemLayoutProcessorResult_Done;
   }
 }
 void CXFA_ItemLayoutProcessor::GetCurrentComponentPos(FX_FLOAT& fAbsoluteX,
                                                       FX_FLOAT& fAbsoluteY) {
   ASSERT(m_pLayoutItem);
   fAbsoluteX = m_pLayoutItem->m_sPos.x;
   fAbsoluteY = m_pLayoutItem->m_sPos.y;
@@ skipping 15 matching lines @@
 
 FX_BOOL CXFA_ItemLayoutProcessor::JudgeLeaderOrTrailerForOccur(
     CXFA_Node* pFormNode) {
   if (!pFormNode)
     return FALSE;
 
   CXFA_Node* pTemplate = pFormNode->GetTemplateNode();
   if (!pTemplate)
     pTemplate = pFormNode;
 
-  CXFA_Occur NodeOccur(pTemplate->GetFirstChildByClass(XFA_ELEMENT_Occur));
+  CXFA_Occur NodeOccur(pTemplate->GetFirstChildByClass(XFA_Element::Occur));
   int32_t iMax = NodeOccur.GetMax();
   if (iMax < 0)
     return TRUE;
 
   int32_t iCount = m_PendingNodesCount[pTemplate];
   if (iCount >= iMax)
     return FALSE;
 
   m_PendingNodesCount[pTemplate] = iCount + 1;
   return TRUE;
 }