Convert XFA_ELEMENT to an enum class

xfa/fxfa/parser/xfa_document_datamerger_imp.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_document_datamerger_imp.h"
 
 #include "core/fxcrt/include/fx_ext.h"
 #include "xfa/fde/xml/fde_xml_imp.h"
@@ skipping 20 matching lines @@
   }
   CXFA_Occur occur(pOccurNode);
   return occur.GetOccurInfo(iMin, iMax, iInit);
 }
 struct XFA_DataMerge_RecurseRecord {
   CXFA_Node* pTemplateChild;
   CXFA_Node* pDataChild;
 };
 static CXFA_Node* XFA_DataMerge_FormValueNode_CreateChild(
     CXFA_Node* pValueNode,
-    XFA_ELEMENT iType = XFA_ELEMENT_UNKNOWN) {
+    XFA_Element iType = XFA_Element::Unknown) {
   CXFA_Node* pChildNode = pValueNode->GetNodeItem(XFA_NODEITEM_FirstChild);
   if (!pChildNode) {
-    if (iType == XFA_ELEMENT_UNKNOWN) {
+    if (iType == XFA_Element::Unknown) {
       return FALSE;
     }
     pChildNode = pValueNode->GetProperty(0, iType);
   }
   return pChildNode;
 }
 static void XFA_DataMerge_FormValueNode_MatchNoneCreateChild(
     CXFA_Node* pFormNode) {
   CXFA_WidgetData* pWidgetData = pFormNode->GetWidgetData();
   ASSERT(pWidgetData);
   pWidgetData->GetUIType();
 }
 static FX_BOOL XFA_DataMerge_FormValueNode_SetChildContent(
     CXFA_Node* pValueNode,
     const CFX_WideString& wsContent,
-    XFA_ELEMENT iType = XFA_ELEMENT_UNKNOWN) {
+    XFA_Element iType = XFA_Element::Unknown) {
   if (!pValueNode) {
     return FALSE;
   }
   ASSERT(pValueNode->GetPacketID() == XFA_XDPPACKET_Form);
   CXFA_Node* pChildNode =
       XFA_DataMerge_FormValueNode_CreateChild(pValueNode, iType);
   if (!pChildNode)
     return FALSE;
 
   switch (pChildNode->GetObjectType()) {
     case XFA_ObjectType::ContentNode: {
       CXFA_Node* pContentRawDataNode =
           pChildNode->GetNodeItem(XFA_NODEITEM_FirstChild);
       if (!pContentRawDataNode) {
-        XFA_ELEMENT element = XFA_ELEMENT_Sharptext;
-        if (pChildNode->GetClassID() == XFA_ELEMENT_ExData) {
+        XFA_Element element = XFA_Element::Sharptext;
+        if (pChildNode->GetClassID() == XFA_Element::ExData) {
           CFX_WideString wsContentType;
           pChildNode->GetAttribute(XFA_ATTRIBUTE_ContentType, wsContentType,
                                    FALSE);
           if (wsContentType == FX_WSTRC(L"text/html")) {
-            element = XFA_ELEMENT_SharpxHTML;
+            element = XFA_Element::SharpxHTML;
           } else if (wsContentType == FX_WSTRC(L"text/xml")) {
-            element = XFA_ELEMENT_Sharpxml;
+            element = XFA_Element::Sharpxml;
           }
         }
         pContentRawDataNode = pChildNode->CreateSamePacketNode(element);
         pChildNode->InsertChild(pContentRawDataNode);
       }
       pContentRawDataNode->SetCData(XFA_ATTRIBUTE_Value, wsContent);
     } break;
     case XFA_ObjectType::NodeC:
     case XFA_ObjectType::TextNode:
     case XFA_ObjectType::NodeV: {
       pChildNode->SetCData(XFA_ATTRIBUTE_Value, wsContent);
     } break;
     default:
       ASSERT(FALSE);
       break;
   }
   return TRUE;
 }
 static void XFA_DataMerge_CreateDataBinding(CXFA_Node* pFormNode,
                                             CXFA_Node* pDataNode,
                                             FX_BOOL bDataToForm = TRUE) {
   pFormNode->SetObject(XFA_ATTRIBUTE_BindingNode, pDataNode);
   pDataNode->AddBindItem(pFormNode);
-  XFA_ELEMENT eClass = pFormNode->GetClassID();
-  if (eClass != XFA_ELEMENT_Field && eClass != XFA_ELEMENT_ExclGroup) {
+  XFA_Element eClass = pFormNode->GetClassID();
+  if (eClass != XFA_Element::Field && eClass != XFA_Element::ExclGroup) {
     return;
   }
   CXFA_WidgetData* pWidgetData = pFormNode->GetWidgetData();
   ASSERT(pWidgetData);
-  XFA_ELEMENT eUIType = pWidgetData->GetUIType();
-  CXFA_Value defValue(pFormNode->GetProperty(0, XFA_ELEMENT_Value));
+  XFA_Element eUIType = pWidgetData->GetUIType();
+  CXFA_Value defValue(pFormNode->GetProperty(0, XFA_Element::Value));
   if (!bDataToForm) {
     CFX_WideString wsValue;
     CFX_WideString wsFormatedValue;
     switch (eUIType) {
-      case XFA_ELEMENT_ImageEdit: {
+      case XFA_Element::ImageEdit: {
         CXFA_Image image = defValue.GetImage();
         CFX_WideString wsContentType;
         CFX_WideString wsHref;
         if (image) {
           image.GetContent(wsValue);
           image.GetContentType(wsContentType);
           image.GetHref(wsHref);
         }
         CFDE_XMLElement* pXMLDataElement =
             static_cast<CFDE_XMLElement*>(pDataNode->GetXMLMappingNode());
         ASSERT(pXMLDataElement);
         pWidgetData->GetFormatDataValue(wsValue, wsFormatedValue);
         pDataNode->SetAttributeValue(wsValue, wsFormatedValue);
         pDataNode->SetCData(XFA_ATTRIBUTE_ContentType, wsContentType);
         if (!wsHref.IsEmpty()) {
           pXMLDataElement->SetString(L"href", wsHref);
         }
       } break;
-      case XFA_ELEMENT_ChoiceList:
+      case XFA_Element::ChoiceList:
         defValue.GetChildValueContent(wsValue);
         if (pWidgetData->GetChoiceListOpen() == XFA_ATTRIBUTEENUM_MultiSelect) {
           CFX_WideStringArray wsSelTextArray;
           pWidgetData->GetSelectedItemsValue(wsSelTextArray);
           int32_t iSize = wsSelTextArray.GetSize();
           if (iSize >= 1) {
             CXFA_Node* pValue = NULL;
             for (int32_t i = 0; i < iSize; i++) {
-              pValue = pDataNode->CreateSamePacketNode(XFA_ELEMENT_DataValue);
+              pValue = pDataNode->CreateSamePacketNode(XFA_Element::DataValue);
               pValue->SetCData(XFA_ATTRIBUTE_Name, L"value");
               pValue->CreateXMLMappingNode();
               pDataNode->InsertChild(pValue);
               pValue->SetCData(XFA_ATTRIBUTE_Value, wsSelTextArray[i]);
             }
           } else {
             CFDE_XMLNode* pXMLNode = pDataNode->GetXMLMappingNode();
             ASSERT(pXMLNode->GetType() == FDE_XMLNODE_Element);
             static_cast<CFDE_XMLElement*>(pXMLNode)->SetString(L"xfa:dataNode",
                                                                L"dataGroup");
           }
         } else if (!wsValue.IsEmpty()) {
           pWidgetData->GetFormatDataValue(wsValue, wsFormatedValue);
           pDataNode->SetAttributeValue(wsValue, wsFormatedValue);
         }
         break;
-      case XFA_ELEMENT_CheckButton:
+      case XFA_Element::CheckButton:
         defValue.GetChildValueContent(wsValue);
         if (wsValue.IsEmpty()) {
           break;
         }
         pWidgetData->GetFormatDataValue(wsValue, wsFormatedValue);
         pDataNode->SetAttributeValue(wsValue, wsFormatedValue);
         break;
-      case XFA_ELEMENT_ExclGroup: {
+      case XFA_Element::ExclGroup: {
         CXFA_Node* pChecked = NULL;
         CXFA_Node* pChild = pFormNode->GetNodeItem(XFA_NODEITEM_FirstChild);
         for (; pChild; pChild = pChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-          if (pChild->GetClassID() != XFA_ELEMENT_Field) {
+          if (pChild->GetClassID() != XFA_Element::Field) {
             continue;
           }
-          CXFA_Node* pValue = pChild->GetChild(0, XFA_ELEMENT_Value);
+          CXFA_Node* pValue = pChild->GetChild(0, XFA_Element::Value);
           if (!pValue) {
             continue;
           }
           CXFA_Value valueChild(pValue);
           valueChild.GetChildValueContent(wsValue);
           if (wsValue.IsEmpty()) {
             continue;
           }
-          CXFA_Node* pItems = pChild->GetChild(0, XFA_ELEMENT_Items);
+          CXFA_Node* pItems = pChild->GetChild(0, XFA_Element::Items);
           if (!pItems) {
             continue;
           }
           CXFA_Node* pText = pItems->GetNodeItem(XFA_NODEITEM_FirstChild);
           if (!pText) {
             continue;
           }
           CFX_WideString wsContent;
           if (pText->TryContent(wsContent) && (wsContent == wsValue)) {
             pChecked = pChild;
             wsFormatedValue = wsValue;
             pDataNode->SetAttributeValue(wsValue, wsFormatedValue);
             pFormNode->SetCData(XFA_ATTRIBUTE_Value, wsContent);
             break;
           }
         }
         if (!pChecked) {
           break;
         }
         pChild = pFormNode->GetNodeItem(XFA_NODEITEM_FirstChild);
         for (; pChild; pChild = pChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {
           if (pChild == pChecked) {
             continue;
           }
-          if (pChild->GetClassID() != XFA_ELEMENT_Field) {
+          if (pChild->GetClassID() != XFA_Element::Field) {
             continue;
           }
-          CXFA_Node* pValue = pChild->GetProperty(0, XFA_ELEMENT_Value);
-          CXFA_Node* pItems = pChild->GetChild(0, XFA_ELEMENT_Items);
+          CXFA_Node* pValue = pChild->GetProperty(0, XFA_Element::Value);
+          CXFA_Node* pItems = pChild->GetChild(0, XFA_Element::Items);
           CXFA_Node* pText =
               pItems ? pItems->GetNodeItem(XFA_NODEITEM_FirstChild) : NULL;
           if (pText) {
             pText = pText->GetNodeItem(XFA_NODEITEM_NextSibling);
           }
           CFX_WideString wsContent;
           if (pText) {
             pText->TryContent(wsContent);
           }
           XFA_DataMerge_FormValueNode_SetChildContent(pValue, wsContent,
-                                                      XFA_ELEMENT_Text);
+                                                      XFA_Element::Text);
         }
       } break;
-      case XFA_ELEMENT_NumericEdit: {
+      case XFA_Element::NumericEdit: {
         defValue.GetChildValueContent(wsValue);
         if (wsValue.IsEmpty()) {
           break;
         }
         CFX_WideString wsOutput;
         pWidgetData->NormalizeNumStr(wsValue, wsOutput);
         wsValue = wsOutput;
         pWidgetData->GetFormatDataValue(wsValue, wsFormatedValue);
         pDataNode->SetAttributeValue(wsValue, wsFormatedValue);
-        CXFA_Node* pValue = pFormNode->GetProperty(0, XFA_ELEMENT_Value);
+        CXFA_Node* pValue = pFormNode->GetProperty(0, XFA_Element::Value);
         XFA_DataMerge_FormValueNode_SetChildContent(pValue, wsValue,
-                                                    XFA_ELEMENT_Float);
+                                                    XFA_Element::Float);
       } break;
       default:
         defValue.GetChildValueContent(wsValue);
         if (wsValue.IsEmpty()) {
           break;
         }
         pWidgetData->GetFormatDataValue(wsValue, wsFormatedValue);
         pDataNode->SetAttributeValue(wsValue, wsFormatedValue);
         break;
     }
   } else {
     CFX_WideString wsXMLValue;
     pDataNode->TryContent(wsXMLValue);
     CFX_WideString wsNormailizeValue;
     pWidgetData->GetNormalizeDataValue(wsXMLValue, wsNormailizeValue);
     pDataNode->SetAttributeValue(wsNormailizeValue, wsXMLValue);
     switch (eUIType) {
-      case XFA_ELEMENT_ImageEdit: {
+      case XFA_Element::ImageEdit: {
         XFA_DataMerge_FormValueNode_SetChildContent(
-            defValue.GetNode(), wsNormailizeValue, XFA_ELEMENT_Image);
+            defValue.GetNode(), wsNormailizeValue, XFA_Element::Image);
         CXFA_Image image = defValue.GetImage();
         if (image) {
           CFDE_XMLElement* pXMLDataElement =
               static_cast<CFDE_XMLElement*>(pDataNode->GetXMLMappingNode());
           ASSERT(pXMLDataElement);
           CFX_WideString wsContentType;
           CFX_WideString wsHref;
           pXMLDataElement->GetString(L"xfa:contentType", wsContentType);
           if (!wsContentType.IsEmpty()) {
             pDataNode->SetCData(XFA_ATTRIBUTE_ContentType, wsContentType);
             image.SetContentType(wsContentType);
           }
           pXMLDataElement->GetString(L"href", wsHref);
           if (!wsHref.IsEmpty()) {
             image.SetHref(wsHref);
           }
         }
       } break;
-      case XFA_ELEMENT_ChoiceList:
+      case XFA_Element::ChoiceList:
         if (pWidgetData->GetChoiceListOpen() == XFA_ATTRIBUTEENUM_MultiSelect) {
           CXFA_NodeArray items;
           pDataNode->GetNodeList(items);
           int32_t iCounts = items.GetSize();
           if (iCounts > 0) {
             wsNormailizeValue.clear();
             CFX_WideString wsItem;
             for (int32_t i = 0; i < iCounts; i++) {
               items[i]->TryContent(wsItem);
               wsItem = (iCounts == 1) ? wsItem : wsItem + FX_WSTRC(L"\n");
               wsNormailizeValue += wsItem;
             }
             CXFA_ExData exData = defValue.GetExData();
             ASSERT(exData);
             exData.SetContentType(iCounts == 1 ? L"text/plain" : L"text/xml");
           }
           XFA_DataMerge_FormValueNode_SetChildContent(
-              defValue.GetNode(), wsNormailizeValue, XFA_ELEMENT_ExData);
+              defValue.GetNode(), wsNormailizeValue, XFA_Element::ExData);
         } else {
           XFA_DataMerge_FormValueNode_SetChildContent(
-              defValue.GetNode(), wsNormailizeValue, XFA_ELEMENT_Text);
+              defValue.GetNode(), wsNormailizeValue, XFA_Element::Text);
         }
         break;
-      case XFA_ELEMENT_CheckButton:
+      case XFA_Element::CheckButton:
         XFA_DataMerge_FormValueNode_SetChildContent(
-            defValue.GetNode(), wsNormailizeValue, XFA_ELEMENT_Text);
+            defValue.GetNode(), wsNormailizeValue, XFA_Element::Text);
         break;
-      case XFA_ELEMENT_ExclGroup: {
+      case XFA_Element::ExclGroup: {
         pWidgetData->SetSelectedMemberByValue(wsNormailizeValue.AsStringC(),
                                               false, FALSE, FALSE);
       } break;
-      case XFA_ELEMENT_DateTimeEdit:
+      case XFA_Element::DateTimeEdit:
         XFA_DataMerge_FormValueNode_SetChildContent(
-            defValue.GetNode(), wsNormailizeValue, XFA_ELEMENT_DateTime);
+            defValue.GetNode(), wsNormailizeValue, XFA_Element::DateTime);
         break;
-      case XFA_ELEMENT_NumericEdit: {
+      case XFA_Element::NumericEdit: {
         CFX_WideString wsPicture;
         pWidgetData->GetPictureContent(wsPicture, XFA_VALUEPICTURE_DataBind);
         if (wsPicture.IsEmpty()) {
           CFX_WideString wsOutput;
           pWidgetData->NormalizeNumStr(wsNormailizeValue, wsOutput);
           wsNormailizeValue = wsOutput;
         }
         XFA_DataMerge_FormValueNode_SetChildContent(
-            defValue.GetNode(), wsNormailizeValue, XFA_ELEMENT_Float);
+            defValue.GetNode(), wsNormailizeValue, XFA_Element::Float);
       } break;
-      case XFA_ELEMENT_Barcode:
-      case XFA_ELEMENT_Button:
-      case XFA_ELEMENT_PasswordEdit:
-      case XFA_ELEMENT_Signature:
-      case XFA_ELEMENT_TextEdit:
+      case XFA_Element::Barcode:
+      case XFA_Element::Button:
+      case XFA_Element::PasswordEdit:
+      case XFA_Element::Signature:
+      case XFA_Element::TextEdit:
       default:
         XFA_DataMerge_FormValueNode_SetChildContent(
-            defValue.GetNode(), wsNormailizeValue, XFA_ELEMENT_Text);
+            defValue.GetNode(), wsNormailizeValue, XFA_Element::Text);
         break;
     }
   }
 }
 static CXFA_Node* XFA_DataMerge_GetGlobalBinding(CXFA_Document* pDocument,
                                                  uint32_t dwNameHash) {
   CXFA_Node* pNode = NULL;
   pDocument->m_rgGlobalBinding.Lookup(dwNameHash, pNode);
   return pNode;
 }
 static void XFA_DataMerge_RegisterGlobalBinding(CXFA_Document* pDocument,
                                                 uint32_t dwNameHash,
                                                 CXFA_Node* pDataNode) {
   pDocument->m_rgGlobalBinding.SetAt(dwNameHash, pDataNode);
 }
 static void XFA_DataMerge_ClearGlobalBinding(CXFA_Document* pDocument) {
   pDocument->m_rgGlobalBinding.RemoveAll();
 }
 static CXFA_Node* XFA_DataMerge_ScopeMatchGlobalBinding(
     CXFA_Node* pDataScope,
     uint32_t dwNameHash,
-    XFA_ELEMENT eMatchDataNodeType,
+    XFA_Element eMatchDataNodeType,
     FX_BOOL bUpLevel = TRUE) {
   for (CXFA_Node *pCurDataScope = pDataScope, *pLastDataScope = NULL;
        pCurDataScope && pCurDataScope->GetPacketID() == XFA_XDPPACKET_Datasets;
        pLastDataScope = pCurDataScope,
                  pCurDataScope =
                      pCurDataScope->GetNodeItem(XFA_NODEITEM_Parent)) {
     for (CXFA_Node* pDataChild = pCurDataScope->GetFirstChildByName(dwNameHash);
          pDataChild;
          pDataChild = pDataChild->GetNextSameNameSibling(dwNameHash)) {
       if (pDataChild == pLastDataScope ||
-          (eMatchDataNodeType != XFA_ELEMENT_DataModel &&
+          (eMatchDataNodeType != XFA_Element::DataModel &&
            pDataChild->GetClassID() != eMatchDataNodeType) ||
           pDataChild->HasBindItem()) {
         continue;
       }
       return pDataChild;
     }
     for (CXFA_Node* pDataChild =
-             pCurDataScope->GetFirstChildByClass(XFA_ELEMENT_DataGroup);
+             pCurDataScope->GetFirstChildByClass(XFA_Element::DataGroup);
          pDataChild; pDataChild = pDataChild->GetNextSameClassSibling(
-                         XFA_ELEMENT_DataGroup)) {
+                         XFA_Element::DataGroup)) {
       CXFA_Node* pDataNode = XFA_DataMerge_ScopeMatchGlobalBinding(
           pDataChild, dwNameHash, eMatchDataNodeType, FALSE);
       if (pDataNode) {
         return pDataNode;
       }
     }
     if (!bUpLevel) {
       break;
     }
   }
   return NULL;
 }
 static CXFA_Node* XFA_DataMerge_FindGlobalDataNode(CXFA_Document* pDocument,
                                                    CFX_WideStringC wsName,
                                                    CXFA_Node* pDataScope,
-                                                   XFA_ELEMENT eMatchNodeType) {
+                                                   XFA_Element eMatchNodeType) {
   if (wsName.IsEmpty())
     return nullptr;
 
   uint32_t dwNameHash = FX_HashCode_GetW(wsName, false);
   CXFA_Node* pBounded = XFA_DataMerge_GetGlobalBinding(pDocument, dwNameHash);
   if (!pBounded) {
     pBounded = XFA_DataMerge_ScopeMatchGlobalBinding(pDataScope, dwNameHash,
                                                      eMatchNodeType);
     if (pBounded) {
       XFA_DataMerge_RegisterGlobalBinding(pDocument, dwNameHash, pBounded);
     }
   }
   return pBounded;
 }
 
 static CXFA_Node* XFA_DataMerge_FindOnceDataNode(CXFA_Document* pDocument,
                                                  CFX_WideStringC wsName,
                                                  CXFA_Node* pDataScope,
-                                                 XFA_ELEMENT eMatchNodeType) {
+                                                 XFA_Element eMatchNodeType) {
   if (wsName.IsEmpty())
     return nullptr;
 
   uint32_t dwNameHash = FX_HashCode_GetW(wsName, false);
   CXFA_Node* pLastDataScope = nullptr;
   for (CXFA_Node* pCurDataScope = pDataScope;
        pCurDataScope && pCurDataScope->GetPacketID() == XFA_XDPPACKET_Datasets;
        pCurDataScope = pCurDataScope->GetNodeItem(XFA_NODEITEM_Parent)) {
     for (CXFA_Node* pDataChild = pCurDataScope->GetFirstChildByName(dwNameHash);
          pDataChild;
          pDataChild = pDataChild->GetNextSameNameSibling(dwNameHash)) {
       if (pDataChild == pLastDataScope || pDataChild->HasBindItem() ||
-          (eMatchNodeType != XFA_ELEMENT_DataModel &&
+          (eMatchNodeType != XFA_Element::DataModel &&
            pDataChild->GetClassID() != eMatchNodeType)) {
         continue;
       }
       return pDataChild;
     }
     pLastDataScope = pCurDataScope;
   }
   return nullptr;
 }
 
 static CXFA_Node* XFA_DataMerge_FindDataRefDataNode(CXFA_Document* pDocument,
                                                     CFX_WideStringC wsRef,
                                                     CXFA_Node* pDataScope,
-                                                    XFA_ELEMENT eMatchNodeType,
+                                                    XFA_Element eMatchNodeType,
                                                     CXFA_Node* pTemplateNode,
                                                     FX_BOOL bForceBind,
                                                     FX_BOOL bUpLevel = TRUE) {
   uint32_t dFlags = XFA_RESOLVENODE_Children | XFA_RESOLVENODE_BindNew;
   if (bUpLevel || wsRef != FX_WSTRC(L"name")) {
     dFlags |= (XFA_RESOLVENODE_Parent | XFA_RESOLVENODE_Siblings);
   }
   XFA_RESOLVENODE_RS rs;
   pDocument->GetScriptContext()->ResolveObjects(pDataScope, wsRef, rs, dFlags,
                                                 pTemplateNode);
   if (rs.dwFlags == XFA_RESOLVENODE_RSTYPE_CreateNodeAll ||
       rs.dwFlags == XFA_RESOLVENODE_RSTYPE_CreateNodeMidAll ||
       rs.nodes.GetSize() > 1) {
     return pDocument->GetNotBindNode(rs.nodes);
   }
   if (rs.dwFlags == XFA_RESOLVENODE_RSTYPE_CreateNodeOne) {
     CXFA_Object* pObject = (rs.nodes.GetSize() > 0) ? rs.nodes[0] : NULL;
     CXFA_Node* pNode = ToNode(pObject);
     if (!bForceBind && pNode && pNode->HasBindItem()) {
       pNode = NULL;
     }
     return pNode;
   }
   return NULL;
 }
 CXFA_Node* XFA_DataMerge_FindFormDOMInstance(CXFA_Document* pDocument,
-                                             XFA_ELEMENT eClassID,
+                                             XFA_Element eClassID,
                                              uint32_t dwNameHash,
                                              CXFA_Node* pFormParent) {
   CXFA_Node* pFormChild = pFormParent->GetNodeItem(XFA_NODEITEM_FirstChild);
   for (; pFormChild;
        pFormChild = pFormChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     if (pFormChild->GetClassID() == eClassID &&
         pFormChild->GetNameHash() == dwNameHash && pFormChild->IsUnusedNode()) {
       return pFormChild;
     }
   }
   return NULL;
 }
 static FX_BOOL XFA_NeedGenerateForm(CXFA_Node* pTemplateChild,
                                     FX_BOOL bUseInstanceManager = TRUE) {
-  XFA_ELEMENT eType = pTemplateChild->GetClassID();
-  if (eType == XFA_ELEMENT_Variables) {
+  XFA_Element eType = pTemplateChild->GetClassID();
+  if (eType == XFA_Element::Variables) {
     return TRUE;
   }
   if (pTemplateChild->IsContainerNode()) {
     return FALSE;
   }
-  if (eType == XFA_ELEMENT_Proto ||
-      (bUseInstanceManager && eType == XFA_ELEMENT_Occur)) {
+  if (eType == XFA_Element::Proto ||
+      (bUseInstanceManager && eType == XFA_Element::Occur)) {
     return FALSE;
   }
   return TRUE;
 }
 CXFA_Node* XFA_NodeMerge_CloneOrMergeContainer(CXFA_Document* pDocument,
                                                CXFA_Node* pFormParent,
                                                CXFA_Node* pTemplateNode,
                                                FX_BOOL bRecursive,
                                                CXFA_NodeArray* pSubformArray) {
   CXFA_Node* pExistingNode = NULL;
   if (pSubformArray == NULL) {
     pExistingNode = XFA_DataMerge_FindFormDOMInstance(
         pDocument, pTemplateNode->GetClassID(), pTemplateNode->GetNameHash(),
         pFormParent);
   } else if (pSubformArray->GetSize() > 0) {
     pExistingNode = pSubformArray->GetAt(0);
     pSubformArray->RemoveAt(0);
   }
   if (pExistingNode) {
     if (pSubformArray) {
       pFormParent->InsertChild(pExistingNode);
     } else if (pExistingNode->IsContainerNode()) {
       pFormParent->RemoveChild(pExistingNode);
       pFormParent->InsertChild(pExistingNode);
     }
     pExistingNode->ClearFlag(XFA_NodeFlag_UnusedNode);
     pExistingNode->SetTemplateNode(pTemplateNode);
-    if (bRecursive && pExistingNode->GetClassID() != XFA_ELEMENT_Items) {
+    if (bRecursive && pExistingNode->GetClassID() != XFA_Element::Items) {
       for (CXFA_Node* pTemplateChild =
                pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild);
            pTemplateChild; pTemplateChild = pTemplateChild->GetNodeItem(
                                XFA_NODEITEM_NextSibling)) {
         if (XFA_NeedGenerateForm(pTemplateChild)) {
           XFA_NodeMerge_CloneOrMergeContainer(pDocument, pExistingNode,
                                               pTemplateChild, bRecursive);
         }
       }
     }
@@ skipping 18 matching lines @@
 static CXFA_Node* XFA_NodeMerge_CloneOrMergeInstanceManager(
     CXFA_Document* pDocument,
     CXFA_Node* pFormParent,
     CXFA_Node* pTemplateNode,
     CXFA_NodeArray& subforms) {
   CFX_WideStringC wsSubformName = pTemplateNode->GetCData(XFA_ATTRIBUTE_Name);
   CFX_WideString wsInstMgrNodeName = FX_WSTRC(L"_") + wsSubformName;
   uint32_t dwInstNameHash =
       FX_HashCode_GetW(wsInstMgrNodeName.AsStringC(), false);
   CXFA_Node* pExistingNode = XFA_DataMerge_FindFormDOMInstance(
-      pDocument, XFA_ELEMENT_InstanceManager, dwInstNameHash, pFormParent);
+      pDocument, XFA_Element::InstanceManager, dwInstNameHash, pFormParent);
   if (pExistingNode) {
     uint32_t dwNameHash = pTemplateNode->GetNameHash();
     for (CXFA_Node* pNode =
              pExistingNode->GetNodeItem(XFA_NODEITEM_NextSibling);
          pNode;) {
-      XFA_ELEMENT eCurType = pNode->GetClassID();
-      if (eCurType == XFA_ELEMENT_InstanceManager) {
+      XFA_Element eCurType = pNode->GetClassID();
+      if (eCurType == XFA_Element::InstanceManager) {
         break;
       }
-      if ((eCurType != XFA_ELEMENT_Subform) &&
-          (eCurType != XFA_ELEMENT_SubformSet)) {
+      if ((eCurType != XFA_Element::Subform) &&
+          (eCurType != XFA_Element::SubformSet)) {
         pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling);
         continue;
       }
       if (dwNameHash != pNode->GetNameHash()) {
         break;
       }
       CXFA_Node* pNextNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling);
       pFormParent->RemoveChild(pNode);
       subforms.Add(pNode);
       pNode = pNextNode;
     }
     pFormParent->RemoveChild(pExistingNode);
     pFormParent->InsertChild(pExistingNode);
     pExistingNode->ClearFlag(XFA_NodeFlag_UnusedNode);
     pExistingNode->SetTemplateNode(pTemplateNode);
     return pExistingNode;
   }
   CXFA_Node* pNewNode = pDocument->GetParser()->GetFactory()->CreateNode(
-      XFA_XDPPACKET_Form, XFA_ELEMENT_InstanceManager);
+      XFA_XDPPACKET_Form, XFA_Element::InstanceManager);
   ASSERT(pNewNode);
   wsInstMgrNodeName =
       FX_WSTRC(L"_") + pTemplateNode->GetCData(XFA_ATTRIBUTE_Name);
   pNewNode->SetCData(XFA_ATTRIBUTE_Name, wsInstMgrNodeName);
   pFormParent->InsertChild(pNewNode, NULL);
   pNewNode->SetTemplateNode(pTemplateNode);
   return pNewNode;
 }
 static CXFA_Node* XFA_DataMerge_FindMatchingDataNode(
     CXFA_Document* pDocument,
     CXFA_Node* pTemplateNode,
     CXFA_Node* pDataScope,
     FX_BOOL& bAccessedDataDOM,
     FX_BOOL bForceBind,
     CXFA_NodeIteratorTemplate<CXFA_Node,
                               CXFA_TraverseStrategy_XFAContainerNode>*
         pIterator,
     FX_BOOL& bSelfMatch,
     XFA_ATTRIBUTEENUM& eBindMatch,
     FX_BOOL bUpLevel = TRUE) {
   FX_BOOL bOwnIterator = FALSE;
   if (!pIterator) {
     bOwnIterator = TRUE;
     pIterator = new CXFA_NodeIteratorTemplate<
         CXFA_Node, CXFA_TraverseStrategy_XFAContainerNode>(pTemplateNode);
   }
   CXFA_Node* pResult = NULL;
   for (CXFA_Node* pCurTemplateNode = pIterator->GetCurrent();
        pCurTemplateNode;) {
-    XFA_ELEMENT eMatchNodeType;
+    XFA_Element eMatchNodeType;
     switch (pCurTemplateNode->GetClassID()) {
-      case XFA_ELEMENT_Subform:
-        eMatchNodeType = XFA_ELEMENT_DataGroup;
+      case XFA_Element::Subform:
+        eMatchNodeType = XFA_Element::DataGroup;
         break;
-      case XFA_ELEMENT_Field: {
+      case XFA_Element::Field: {
         eMatchNodeType = XFA_FieldIsMultiListBox(pCurTemplateNode)
-                             ? XFA_ELEMENT_DataGroup
-                             : XFA_ELEMENT_DataValue;
+                             ? XFA_Element::DataGroup
+                             : XFA_Element::DataValue;
       } break;
-      case XFA_ELEMENT_ExclGroup:
-        eMatchNodeType = XFA_ELEMENT_DataValue;
+      case XFA_Element::ExclGroup:
+        eMatchNodeType = XFA_Element::DataValue;
         break;
       default:
         pCurTemplateNode = pIterator->MoveToNext();
         continue;
     }
     CXFA_Node* pTemplateNodeOccur =
-        pCurTemplateNode->GetFirstChildByClass(XFA_ELEMENT_Occur);
+        pCurTemplateNode->GetFirstChildByClass(XFA_Element::Occur);
     int32_t iMin, iMax, iInit;
     if (pTemplateNodeOccur &&
         XFA_GetOccurInfo(pTemplateNodeOccur, iMin, iMax, iInit) && iMax == 0) {
       pCurTemplateNode = pIterator->MoveToNext();
       continue;
     }
     CXFA_Node* pTemplateNodeBind =
-        pCurTemplateNode->GetFirstChildByClass(XFA_ELEMENT_Bind);
+        pCurTemplateNode->GetFirstChildByClass(XFA_Element::Bind);
     XFA_ATTRIBUTEENUM eMatch =
         pTemplateNodeBind ? pTemplateNodeBind->GetEnum(XFA_ATTRIBUTE_Match)
                           : XFA_ATTRIBUTEENUM_Once;
     eBindMatch = eMatch;
     switch (eMatch) {
       case XFA_ATTRIBUTEENUM_None:
         pCurTemplateNode = pIterator->MoveToNext();
         continue;
       case XFA_ATTRIBUTEENUM_Global:
         bAccessedDataDOM = TRUE;
         if (!bForceBind) {
           pCurTemplateNode = pIterator->MoveToNext();
           continue;
         }
-        if (eMatchNodeType == XFA_ELEMENT_DataValue ||
-            (eMatchNodeType == XFA_ELEMENT_DataGroup &&
+        if (eMatchNodeType == XFA_Element::DataValue ||
+            (eMatchNodeType == XFA_Element::DataGroup &&
              XFA_FieldIsMultiListBox(pTemplateNodeBind))) {
           CXFA_Node* pGlobalBindNode = XFA_DataMerge_FindGlobalDataNode(
               pDocument, pCurTemplateNode->GetCData(XFA_ATTRIBUTE_Name),
               pDataScope, eMatchNodeType);
           if (!pGlobalBindNode) {
             pCurTemplateNode = pIterator->MoveToNext();
             continue;
           }
           pResult = pGlobalBindNode;
           break;
@@ skipping 72 matching lines @@
     rgRecords.Copy(rgResultRecord);
   }
 }
 static CXFA_Node* XFA_DataMerge_CopyContainer_SubformSet(
     CXFA_Document* pDocument,
     CXFA_Node* pTemplateNode,
     CXFA_Node* pFormParentNode,
     CXFA_Node* pDataScope,
     FX_BOOL bOneInstance,
     FX_BOOL bDataMerge) {
-  XFA_ELEMENT eElement = pTemplateNode->GetClassID();
+  XFA_Element eElement = pTemplateNode->GetClassID();
   CXFA_Node* pOccurNode = NULL;
   CXFA_Node* pFirstInstance = NULL;
   FX_BOOL bUseInstanceManager =
-      pFormParentNode->GetClassID() != XFA_ELEMENT_Area;
+      pFormParentNode->GetClassID() != XFA_Element::Area;
   CXFA_Node* pInstMgrNode = NULL;
   CXFA_NodeArray subformArray;
   CXFA_NodeArray* pSearchArray = NULL;
-  if (!bOneInstance &&
-      (eElement == XFA_ELEMENT_SubformSet || eElement == XFA_ELEMENT_Subform)) {
+  if (!bOneInstance && (eElement == XFA_Element::SubformSet ||
+                        eElement == XFA_Element::Subform)) {
     pInstMgrNode =
         bUseInstanceManager
             ? XFA_NodeMerge_CloneOrMergeInstanceManager(
                   pDocument, pFormParentNode, pTemplateNode, subformArray)
             : NULL;
     if (CXFA_Node* pOccurTemplateNode =
-            pTemplateNode->GetFirstChildByClass(XFA_ELEMENT_Occur)) {
+            pTemplateNode->GetFirstChildByClass(XFA_Element::Occur)) {
       pOccurNode = pInstMgrNode
                        ? XFA_NodeMerge_CloneOrMergeContainer(
                              pDocument, pInstMgrNode, pOccurTemplateNode, FALSE)
                        : pOccurTemplateNode;
     } else if (pInstMgrNode) {
-      pOccurNode = pInstMgrNode->GetFirstChildByClass(XFA_ELEMENT_Occur);
+      pOccurNode = pInstMgrNode->GetFirstChildByClass(XFA_Element::Occur);
       if (pOccurNode) {
         pOccurNode->ClearFlag(XFA_NodeFlag_UnusedNode);
       }
     }
     if (pInstMgrNode) {
       pInstMgrNode->SetFlag(XFA_NodeFlag_Initialized, true);
       pSearchArray = &subformArray;
-      if (pFormParentNode->GetClassID() == XFA_ELEMENT_PageArea) {
+      if (pFormParentNode->GetClassID() == XFA_Element::PageArea) {
         bOneInstance = TRUE;
         if (subformArray.GetSize() < 1) {
           pSearchArray = NULL;
         }
       } else if ((pTemplateNode->GetNameHash() == 0) &&
                  (subformArray.GetSize() < 1)) {
         pSearchArray = NULL;
       }
     }
   }
   int32_t iMax = 1, iInit = 1, iMin = 1;
   if (!bOneInstance) {
     XFA_GetOccurInfo(pOccurNode, iMin, iMax, iInit);
   }
   XFA_ATTRIBUTEENUM eRelation =
-      eElement == XFA_ELEMENT_SubformSet
+      eElement == XFA_Element::SubformSet
           ? pTemplateNode->GetEnum(XFA_ATTRIBUTE_Relation)
           : XFA_ATTRIBUTEENUM_Ordered;
   int32_t iCurRepeatIndex = 0;
   XFA_ATTRIBUTEENUM eParentBindMatch = XFA_ATTRIBUTEENUM_None;
   if (bDataMerge) {
     CXFA_NodeIteratorTemplate<CXFA_Node, CXFA_TraverseStrategy_XFAContainerNode>
         sNodeIterator(pTemplateNode);
     FX_BOOL bAccessedDataDOM = FALSE;
-    if (eElement == XFA_ELEMENT_SubformSet || eElement == XFA_ELEMENT_Area) {
+    if (eElement == XFA_Element::SubformSet || eElement == XFA_Element::Area) {
       sNodeIterator.MoveToNext();
     } else {
       CFX_MapPtrTemplate<CXFA_Node*, CXFA_Node*> subformMapArray;
       CXFA_NodeArray nodeArray;
       for (; iMax < 0 || iCurRepeatIndex < iMax; iCurRepeatIndex++) {
         FX_BOOL bSelfMatch = FALSE;
         XFA_ATTRIBUTEENUM eBindMatch = XFA_ATTRIBUTEENUM_None;
         CXFA_Node* pDataNode = XFA_DataMerge_FindMatchingDataNode(
             pDocument, pTemplateNode, pDataScope, bAccessedDataDOM, FALSE,
             &sNodeIterator, bSelfMatch, eBindMatch);
@@ skipping 206 matching lines @@
   CXFA_Node* pFieldNode = XFA_NodeMerge_CloneOrMergeContainer(
       pDocument, pFormNode, pTemplateNode, FALSE);
   ASSERT(pFieldNode);
   for (CXFA_Node* pTemplateChildNode =
            pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild);
        pTemplateChildNode; pTemplateChildNode = pTemplateChildNode->GetNodeItem(
                                XFA_NODEITEM_NextSibling)) {
     if (XFA_NeedGenerateForm(pTemplateChildNode)) {
       XFA_NodeMerge_CloneOrMergeContainer(pDocument, pFieldNode,
                                           pTemplateChildNode, TRUE);
-    } else if (pTemplateNode->GetClassID() == XFA_ELEMENT_ExclGroup &&
+    } else if (pTemplateNode->GetClassID() == XFA_Element::ExclGroup &&
                pTemplateChildNode->IsContainerNode()) {
-      if (pTemplateChildNode->GetClassID() == XFA_ELEMENT_Field) {
+      if (pTemplateChildNode->GetClassID() == XFA_Element::Field) {
         XFA_DataMerge_CopyContainer_Field(pDocument, pTemplateChildNode,
                                           pFieldNode, NULL, FALSE);
       }
     }
   }
   if (bDataMerge) {
     FX_BOOL bAccessedDataDOM = FALSE;
     FX_BOOL bSelfMatch = FALSE;
     XFA_ATTRIBUTEENUM eBindMatch;
     CXFA_Node* pDataNode = XFA_DataMerge_FindMatchingDataNode(
         pDocument, pTemplateNode, pDataScope, bAccessedDataDOM, TRUE, NULL,
         bSelfMatch, eBindMatch, bUpLevel);
     if (pDataNode) {
       XFA_DataMerge_CreateDataBinding(pFieldNode, pDataNode);
     }
   } else {
     XFA_DataMerge_FormValueNode_MatchNoneCreateChild(pFieldNode);
   }
   return pFieldNode;
 }
 CXFA_Node* CXFA_Document::DataMerge_CopyContainer(CXFA_Node* pTemplateNode,
                                                   CXFA_Node* pFormNode,
                                                   CXFA_Node* pDataScope,
                                                   FX_BOOL bOneInstance,
                                                   FX_BOOL bDataMerge,
                                                   FX_BOOL bUpLevel) {
   switch (pTemplateNode->GetClassID()) {
-    case XFA_ELEMENT_SubformSet:
-    case XFA_ELEMENT_Subform:
-    case XFA_ELEMENT_Area:
-    case XFA_ELEMENT_PageArea:
+    case XFA_Element::SubformSet:
+    case XFA_Element::Subform:
+    case XFA_Element::Area:
+    case XFA_Element::PageArea:
       return XFA_DataMerge_CopyContainer_SubformSet(
           this, pTemplateNode, pFormNode, pDataScope, bOneInstance, bDataMerge);
-    case XFA_ELEMENT_ExclGroup:
-    case XFA_ELEMENT_Field:
-    case XFA_ELEMENT_Draw:
-    case XFA_ELEMENT_ContentArea:
+    case XFA_Element::ExclGroup:
+    case XFA_Element::Field:
+    case XFA_Element::Draw:
+    case XFA_Element::ContentArea:
       return XFA_DataMerge_CopyContainer_Field(
           this, pTemplateNode, pFormNode, pDataScope, bDataMerge, bUpLevel);
-    case XFA_ELEMENT_PageSet:
+    case XFA_Element::PageSet:
       break;
-    case XFA_ELEMENT_Variables:
+    case XFA_Element::Variables:
       break;
     default:
       ASSERT(FALSE);
       break;
   }
   return NULL;
 }
 
 static void XFA_DataMerge_UpdateBindingRelations(CXFA_Document* pDocument,
                                                  CXFA_Node* pFormNode,
                                                  CXFA_Node* pDataScope,
                                                  FX_BOOL bDataRef,
                                                  FX_BOOL bParentDataRef) {
   FX_BOOL bMatchRef = TRUE;
-  XFA_ELEMENT eClassID = pFormNode->GetClassID();
+  XFA_Element eClassID = pFormNode->GetClassID();
   CXFA_Node* pDataNode = pFormNode->GetBindData();
-  if (eClassID == XFA_ELEMENT_Subform || eClassID == XFA_ELEMENT_ExclGroup ||
-      eClassID == XFA_ELEMENT_Field) {
+  if (eClassID == XFA_Element::Subform || eClassID == XFA_Element::ExclGroup ||
+      eClassID == XFA_Element::Field) {
     CXFA_Node* pTemplateNode = pFormNode->GetTemplateNode();
     CXFA_Node* pTemplateNodeBind =
-        pTemplateNode ? pTemplateNode->GetFirstChildByClass(XFA_ELEMENT_Bind)
+        pTemplateNode ? pTemplateNode->GetFirstChildByClass(XFA_Element::Bind)
                       : NULL;
     XFA_ATTRIBUTEENUM eMatch =
         pTemplateNodeBind ? pTemplateNodeBind->GetEnum(XFA_ATTRIBUTE_Match)
                           : XFA_ATTRIBUTEENUM_Once;
     switch (eMatch) {
       case XFA_ATTRIBUTEENUM_None:
         if (!bDataRef || bParentDataRef) {
           XFA_DataMerge_FormValueNode_MatchNoneCreateChild(pFormNode);
         }
         break;
       case XFA_ATTRIBUTEENUM_Once:
         if (!bDataRef || bParentDataRef) {
           if (!pDataNode) {
             if (pFormNode->GetNameHash() != 0 &&
                 pFormNode->GetEnum(XFA_ATTRIBUTE_Scope) !=
                     XFA_ATTRIBUTEENUM_None) {
-              XFA_ELEMENT eDataNodeType = (eClassID == XFA_ELEMENT_Subform ||
+              XFA_Element eDataNodeType = (eClassID == XFA_Element::Subform ||
                                            XFA_FieldIsMultiListBox(pFormNode))
-                                              ? XFA_ELEMENT_DataGroup
-                                              : XFA_ELEMENT_DataValue;
+                                              ? XFA_Element::DataGroup
+                                              : XFA_Element::DataValue;
               pDataNode = XFA_DataDescription_MaybeCreateDataNode(
                   pDocument, pDataScope, eDataNodeType,
                   CFX_WideString(pFormNode->GetCData(XFA_ATTRIBUTE_Name)));
               if (pDataNode) {
                 XFA_DataMerge_CreateDataBinding(pFormNode, pDataNode, FALSE);
               }
             }
             if (!pDataNode) {
               XFA_DataMerge_FormValueNode_MatchNoneCreateChild(pFormNode);
             }
           } else {
             CXFA_Node* pDataParent =
                 pDataNode->GetNodeItem(XFA_NODEITEM_Parent);
             if (pDataParent != pDataScope) {
               ASSERT(pDataParent);
               pDataParent->RemoveChild(pDataNode);
               pDataScope->InsertChild(pDataNode);
             }
           }
         }
         break;
       case XFA_ATTRIBUTEENUM_Global:
         if (!bDataRef || bParentDataRef) {
           uint32_t dwNameHash = pFormNode->GetNameHash();
           if (dwNameHash != 0 && !pDataNode) {
             pDataNode = XFA_DataMerge_GetGlobalBinding(pDocument, dwNameHash);
             if (!pDataNode) {
-              XFA_ELEMENT eDataNodeType = (eClassID == XFA_ELEMENT_Subform ||
+              XFA_Element eDataNodeType = (eClassID == XFA_Element::Subform ||
                                            XFA_FieldIsMultiListBox(pFormNode))
-                                              ? XFA_ELEMENT_DataGroup
-                                              : XFA_ELEMENT_DataValue;
+                                              ? XFA_Element::DataGroup
+                                              : XFA_Element::DataValue;
               CXFA_Node* pRecordNode =
                   ToNode(pDocument->GetXFAObject(XFA_HASHCODE_Record));
               pDataNode = XFA_DataDescription_MaybeCreateDataNode(
                   pDocument, pRecordNode, eDataNodeType,
                   CFX_WideString(pFormNode->GetCData(XFA_ATTRIBUTE_Name)));
               if (pDataNode) {
                 XFA_DataMerge_CreateDataBinding(pFormNode, pDataNode, FALSE);
                 XFA_DataMerge_RegisterGlobalBinding(
                     pDocument, pFormNode->GetNameHash(), pDataNode);
               }
@@ skipping 26 matching lines @@
           } else {
             XFA_DataMerge_FormValueNode_MatchNoneCreateChild(pFormNode);
           }
         }
       } break;
       default:
         break;
     }
   }
   if (bMatchRef &&
-      (eClassID == XFA_ELEMENT_Subform || eClassID == XFA_ELEMENT_SubformSet ||
-       eClassID == XFA_ELEMENT_Area || eClassID == XFA_ELEMENT_PageArea ||
-       eClassID == XFA_ELEMENT_PageSet)) {
+      (eClassID == XFA_Element::Subform ||
+       eClassID == XFA_Element::SubformSet || eClassID == XFA_Element::Area ||
+       eClassID == XFA_Element::PageArea || eClassID == XFA_Element::PageSet)) {
     for (CXFA_Node* pFormChild =
              pFormNode->GetNodeItem(XFA_NODEITEM_FirstChild);
          pFormChild;
          pFormChild = pFormChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {
       if (!pFormChild->IsContainerNode())
         continue;
       if (pFormChild->IsUnusedNode())
         continue;
 
       XFA_DataMerge_UpdateBindingRelations(pDocument, pFormChild,
@@ skipping 33 matching lines @@
       return pNode;
   }
   return nullptr;
 }
 void CXFA_Document::DoDataMerge() {
   CXFA_Node* pDatasetsRoot = ToNode(GetXFAObject(XFA_HASHCODE_Datasets));
   if (!pDatasetsRoot) {
     CFDE_XMLElement* pDatasetsXMLNode = new CFDE_XMLElement(L"xfa:datasets");
     pDatasetsXMLNode->SetString(L"xmlns:xfa",
                                 L"http://www.xfa.org/schema/xfa-data/1.0/");
-    pDatasetsRoot = CreateNode(XFA_XDPPACKET_Datasets, XFA_ELEMENT_DataModel);
+    pDatasetsRoot = CreateNode(XFA_XDPPACKET_Datasets, XFA_Element::DataModel);
     pDatasetsRoot->SetCData(XFA_ATTRIBUTE_Name, L"datasets");
     m_pRootNode->GetXMLMappingNode()->InsertChildNode(pDatasetsXMLNode);
     m_pRootNode->InsertChild(pDatasetsRoot);
     pDatasetsRoot->SetXMLMappingNode(pDatasetsXMLNode);
   }
   CXFA_Node *pDataRoot = NULL, *pDDRoot = NULL;
   CFX_WideString wsDatasetsURI;
   pDatasetsRoot->TryNamespace(wsDatasetsURI);
   for (CXFA_Node* pChildNode =
            pDatasetsRoot->GetNodeItem(XFA_NODEITEM_FirstChild);
        pChildNode;
        pChildNode = pChildNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    if (pChildNode->GetClassID() != XFA_ELEMENT_DataGroup) {
+    if (pChildNode->GetClassID() != XFA_Element::DataGroup) {
       continue;
     }
     CFX_WideString wsNamespaceURI;
     if (!pDDRoot && pChildNode->GetNameHash() == XFA_HASHCODE_DataDescription) {
       if (!pChildNode->TryNamespace(wsNamespaceURI)) {
         continue;
       }
       if (wsNamespaceURI ==
           FX_WSTRC(L"http://ns.adobe.com/data-description/")) {
         pDDRoot = pChildNode;
       }
     } else if (!pDataRoot && pChildNode->GetNameHash() == XFA_HASHCODE_Data) {
       if (!pChildNode->TryNamespace(wsNamespaceURI)) {
         continue;
       }
       if (wsNamespaceURI == wsDatasetsURI) {
         pDataRoot = pChildNode;
       }
     }
     if (pDataRoot && pDDRoot) {
       break;
     }
   }
   if (!pDataRoot) {
     CFDE_XMLElement* pDataRootXMLNode = new CFDE_XMLElement(L"xfa:data");
-    pDataRoot = CreateNode(XFA_XDPPACKET_Datasets, XFA_ELEMENT_DataGroup);
+    pDataRoot = CreateNode(XFA_XDPPACKET_Datasets, XFA_Element::DataGroup);
     pDataRoot->SetCData(XFA_ATTRIBUTE_Name, L"data");
     pDataRoot->SetXMLMappingNode(pDataRootXMLNode);
     pDatasetsRoot->InsertChild(pDataRoot);
   }
   CXFA_Node* pDataTopLevel =
-      pDataRoot->GetFirstChildByClass(XFA_ELEMENT_DataGroup);
+      pDataRoot->GetFirstChildByClass(XFA_Element::DataGroup);
   uint32_t dwNameHash = pDataTopLevel ? pDataTopLevel->GetNameHash() : 0;
   CXFA_Node* pTemplateRoot =
-      m_pRootNode->GetFirstChildByClass(XFA_ELEMENT_Template);
+      m_pRootNode->GetFirstChildByClass(XFA_Element::Template);
   if (!pTemplateRoot) {
     return;
   }
   CXFA_Node* pTemplateChosen =
       dwNameHash != 0 ? pTemplateRoot->GetFirstChildByName(dwNameHash) : NULL;
   if (!pTemplateChosen ||
-      pTemplateChosen->GetClassID() != XFA_ELEMENT_Subform) {
-    pTemplateChosen = pTemplateRoot->GetFirstChildByClass(XFA_ELEMENT_Subform);
+      pTemplateChosen->GetClassID() != XFA_Element::Subform) {
+    pTemplateChosen = pTemplateRoot->GetFirstChildByClass(XFA_Element::Subform);
   }
   if (!pTemplateChosen) {
     return;
   }
-  CXFA_Node* pFormRoot = m_pRootNode->GetFirstChildByClass(XFA_ELEMENT_Form);
+  CXFA_Node* pFormRoot = m_pRootNode->GetFirstChildByClass(XFA_Element::Form);
   FX_BOOL bEmptyForm = FALSE;
   if (!pFormRoot) {
     bEmptyForm = TRUE;
-    pFormRoot = CreateNode(XFA_XDPPACKET_Form, XFA_ELEMENT_Form);
+    pFormRoot = CreateNode(XFA_XDPPACKET_Form, XFA_Element::Form);
     ASSERT(pFormRoot);
     pFormRoot->SetCData(XFA_ATTRIBUTE_Name, L"form");
     m_pRootNode->InsertChild(pFormRoot, NULL);
   } else {
     CXFA_NodeIteratorTemplate<CXFA_Node, CXFA_TraverseStrategy_XFANode>
         sIterator(pFormRoot);
     for (CXFA_Node* pNode = sIterator.MoveToNext(); pNode;
          pNode = sIterator.MoveToNext()) {
       pNode->SetFlag(XFA_NodeFlag_UnusedNode, true);
     }
   }
   CXFA_Node* pSubformSetNode = XFA_NodeMerge_CloneOrMergeContainer(
       this, pFormRoot, pTemplateChosen, FALSE);
   ASSERT(pSubformSetNode);
   if (!pDataTopLevel) {
     CFX_WideStringC wsFormName = pSubformSetNode->GetCData(XFA_ATTRIBUTE_Name);
     CFX_WideString wsDataTopLevelName(wsFormName.IsEmpty() ? L"form"
                                                            : wsFormName);
     CFDE_XMLElement* pDataTopLevelXMLNode =
         new CFDE_XMLElement(wsDataTopLevelName);
 
-    pDataTopLevel = CreateNode(XFA_XDPPACKET_Datasets, XFA_ELEMENT_DataGroup);
+    pDataTopLevel = CreateNode(XFA_XDPPACKET_Datasets, XFA_Element::DataGroup);
     pDataTopLevel->SetCData(XFA_ATTRIBUTE_Name, wsDataTopLevelName);
     pDataTopLevel->SetXMLMappingNode(pDataTopLevelXMLNode);
     CXFA_Node* pBeforeNode = pDataRoot->GetNodeItem(XFA_NODEITEM_FirstChild);
     pDataRoot->InsertChild(pDataTopLevel, pBeforeNode);
   }
   ASSERT(pDataTopLevel);
   XFA_DataMerge_CreateDataBinding(pSubformSetNode, pDataTopLevel);
   for (CXFA_Node* pTemplateChild =
            pTemplateChosen->GetNodeItem(XFA_NODEITEM_FirstChild);
        pTemplateChild;
        pTemplateChild = pTemplateChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     if (XFA_NeedGenerateForm(pTemplateChild)) {
       XFA_NodeMerge_CloneOrMergeContainer(this, pSubformSetNode, pTemplateChild,
                                           TRUE);
     } else if (pTemplateChild->IsContainerNode()) {
       DataMerge_CopyContainer(pTemplateChild, pSubformSetNode, pDataTopLevel);
     }
   }
   if (pDDRoot) {
     XFA_DataDescription_UpdateDataRelation(pDataRoot, pDDRoot);
   }
   DataMerge_UpdateBindingRelations(pSubformSetNode);
   CXFA_Node* pPageSetNode =
-      pSubformSetNode->GetFirstChildByClass(XFA_ELEMENT_PageSet);
+      pSubformSetNode->GetFirstChildByClass(XFA_Element::PageSet);
   while (pPageSetNode) {
     m_pPendingPageSet.Add(pPageSetNode);
     CXFA_Node* pNextPageSetNode =
-        pPageSetNode->GetNextSameClassSibling(XFA_ELEMENT_PageSet);
+        pPageSetNode->GetNextSameClassSibling(XFA_Element::PageSet);
     pSubformSetNode->RemoveChild(pPageSetNode);
     pPageSetNode = pNextPageSetNode;
   }
   if (!bEmptyForm) {
     CXFA_NodeIteratorTemplate<CXFA_Node, CXFA_TraverseStrategy_XFANode>
         sIterator(pFormRoot);
     CXFA_Node* pNode = sIterator.MoveToNext();
     while (pNode) {
       if (pNode->IsUnusedNode()) {
         if (pNode->IsContainerNode() ||
-            pNode->GetClassID() == XFA_ELEMENT_InstanceManager) {
+            pNode->GetClassID() == XFA_Element::InstanceManager) {
           CXFA_Node* pNext = sIterator.SkipChildrenAndMoveToNext();
           pNode->GetNodeItem(XFA_NODEITEM_Parent)->RemoveChild(pNode);
           pNode = pNext;
         } else {
           pNode->ClearFlag(XFA_NodeFlag_UnusedNode);
           pNode->SetFlag(XFA_NodeFlag_Initialized, true);
           pNode = sIterator.MoveToNext();
         }
       } else {
         pNode->SetFlag(XFA_NodeFlag_Initialized, true);
@@ skipping 10 matching lines @@
     }
     pFormRoot->SetObject(XFA_ATTRIBUTE_BindingNode, NULL);
   }
   XFA_DataMerge_ClearGlobalBinding(this);
   if (bDoDataMerge) {
     DoDataMerge();
   }
   CXFA_LayoutProcessor* pLayoutProcessor = GetLayoutProcessor();
   pLayoutProcessor->SetForceReLayout(TRUE);
 }