Convert XFA_ELEMENT to an enum class

xfa/fxfa/parser/xfa_object_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_object.h"
 
 #include <memory>
 
@@ skipping 25 matching lines @@
 void XFA_CopyWideString(void*& pData) {
   if (pData) {
     CFX_WideString* pNewData = new CFX_WideString(*(CFX_WideString*)pData);
     pData = pNewData;
   }
 }
 
 XFA_MAPDATABLOCKCALLBACKINFO deleteWideStringCallBack = {XFA_DeleteWideString,
                                                          XFA_CopyWideString};
 
-XFA_ObjectType XFA_GetElementObjectType(XFA_ELEMENT eElement) {
+XFA_ObjectType XFA_GetElementObjectType(XFA_Element eElement) {
   return XFA_GetElementByID(eElement)->eObjectType;
 }
 
 void XFA_DataNodeDeleteBindItem(void* pData) {
   delete static_cast<CXFA_NodeArray*>(pData);
 }
 
 XFA_MAPDATABLOCKCALLBACKINFO deleteBindItemCallBack = {
     XFA_DataNodeDeleteBindItem, nullptr};
 
 }  // namespace
 
 CXFA_Object::CXFA_Object(CXFA_Document* pDocument, XFA_ObjectType type)
     : m_pDocument(pDocument), m_objectType(type) {}
 
 CXFA_Object::~CXFA_Object() {}
 
 void CXFA_Object::GetClassName(CFX_WideStringC& wsName) const {
   wsName = XFA_GetElementByID(GetClassID())->pName;
 }
 
 uint32_t CXFA_Object::GetClassHashCode() const {
   return XFA_GetElementByID(GetClassID())->uHash;
 }
 
-XFA_ELEMENT CXFA_Object::GetClassID() const {
+XFA_Element CXFA_Object::GetClassID() const {
   if (IsNode())
     return AsNode()->GetClassID();
   if (IsOrdinaryObject())
     return AsOrdinaryObject()->GetClassID();
   if (IsNodeList())
     return AsNodeList()->GetClassID();
   if (IsOrdinaryList())
-    return XFA_ELEMENT_List;
+    return XFA_Element::List;
   ASSERT(FALSE);
-  return (XFA_ELEMENT)0;
+  return XFA_Element::Unknown;
 }
 
 void CXFA_Object::Script_ObjectClass_ClassName(CFXJSE_Value* pValue,
                                                FX_BOOL bSetting,
                                                XFA_ATTRIBUTE eAttribute) {
   if (!bSetting) {
     CFX_WideStringC className;
     GetClassName(className);
     pValue->SetString(
         FX_UTF8Encode(className.c_str(), className.GetLength()).AsStringC());
@@ skipping 15 matching lines @@
   FXJSE_ThrowMessage(
       FX_UTF8Encode(wsMessage.c_str(), wsMessage.GetLength()).AsStringC());
 }
 
 XFA_MAPMODULEDATA::XFA_MAPMODULEDATA() {}
 
 XFA_MAPMODULEDATA::~XFA_MAPMODULEDATA() {}
 
 CXFA_Node::CXFA_Node(CXFA_Document* pDoc,
                      uint16_t ePacket,
-                     XFA_ELEMENT eElement)
+                     XFA_Element eElement)
     : CXFA_Object(pDoc, XFA_GetElementObjectType(eElement)),
       m_pNext(nullptr),
       m_pChild(nullptr),
       m_pLastChild(nullptr),
       m_pParent(nullptr),
       m_pXMLNode(nullptr),
       m_eNodeClass(eElement),
       m_ePacket(ePacket),
       m_uNodeFlags(XFA_NodeFlag_None),
       m_dwNameHash(0),
@@ skipping 110 matching lines @@
       }
       break;
     default:
       break;
   }
   return pNode;
 }
 
 int32_t CXFA_Node::GetNodeList(CXFA_NodeArray& nodes,
                                uint32_t dwTypeFilter,
-                               XFA_ELEMENT eElementFilter,
+                               XFA_Element eElementFilter,
                                int32_t iLevel) {
   if (--iLevel < 0) {
     return nodes.GetSize();
   }
-  if (eElementFilter != XFA_ELEMENT_UNKNOWN) {
+  if (eElementFilter != XFA_Element::Unknown) {
     CXFA_Node* pChild = m_pChild;
     while (pChild) {
       if (pChild->GetClassID() == eElementFilter) {
         nodes.Add(pChild);
         if (iLevel > 0) {
           GetNodeList(nodes, dwTypeFilter, eElementFilter, iLevel);
         }
       }
       pChild = pChild->m_pNext;
     }
@@ skipping 16 matching lines @@
     while (pChild) {
       const XFA_PROPERTY* pProperty = XFA_GetPropertyOfElement(
           GetClassID(), pChild->GetClassID(), XFA_XDPPACKET_UNKNOWN);
       if (pProperty) {
         if (bFilterProperties) {
           nodes.Add(pChild);
         } else if (bFilterOneOfProperties &&
                    (pProperty->uFlags & XFA_PROPERTYFLAG_OneOf)) {
           nodes.Add(pChild);
         } else if (bFilterChildren &&
-                   (pChild->GetClassID() == XFA_ELEMENT_Variables ||
-                    pChild->GetClassID() == XFA_ELEMENT_PageSet)) {
+                   (pChild->GetClassID() == XFA_Element::Variables ||
+                    pChild->GetClassID() == XFA_Element::PageSet)) {
           nodes.Add(pChild);
         }
       } else if (bFilterChildren) {
         nodes.Add(pChild);
       }
       pChild = pChild->m_pNext;
     }
     if (bFilterOneOfProperties && nodes.GetSize() < 1) {
       int32_t iProperties = 0;
       const XFA_PROPERTY* pProperty =
           XFA_GetElementProperties(GetClassID(), iProperties);
       if (!pProperty || iProperties < 1)
         return 0;
       for (int32_t i = 0; i < iProperties; i++) {
         if (pProperty[i].uFlags & XFA_PROPERTYFLAG_DefaultOneOf) {
           CXFA_Document* pFactory = m_pDocument->GetParser()->GetFactory();
           const XFA_PACKETINFO* pPacket = XFA_GetPacketByID(GetPacketID());
           CXFA_Node* pNewNode =
-              pFactory->CreateNode(pPacket, (XFA_ELEMENT)pProperty[i].eName);
+              pFactory->CreateNode(pPacket, pProperty[i].eName);
           if (!pNewNode)
             break;
           InsertChild(pNewNode, nullptr);
           pNewNode->SetFlag(XFA_NodeFlag_Initialized, true);
           nodes.Add(pNewNode);
           break;
         }
       }
     }
   }
   return nodes.GetSize();
 }
 
-CXFA_Node* CXFA_Node::CreateSamePacketNode(XFA_ELEMENT eElement,
+CXFA_Node* CXFA_Node::CreateSamePacketNode(XFA_Element eElement,
                                            uint32_t dwFlags) {
   CXFA_Document* pFactory = m_pDocument->GetParser()->GetFactory();
   CXFA_Node* pNode = pFactory->CreateNode(m_ePacket, eElement);
   pNode->SetFlag(dwFlags, true);
   return pNode;
 }
 
 CXFA_Node* CXFA_Node::CloneTemplateToForm(FX_BOOL bRecursive) {
   ASSERT(m_ePacket == XFA_XDPPACKET_Template);
   CXFA_Document* pFactory = m_pDocument->GetParser()->GetFactory();
@@ skipping 102 matching lines @@
          GetObject(XFA_ATTRIBUTE_BindingNode);
 }
 
 CXFA_WidgetData* CXFA_Node::GetWidgetData() {
   return (CXFA_WidgetData*)GetObject(XFA_ATTRIBUTE_WidgetData);
 }
 
 CXFA_WidgetData* CXFA_Node::GetContainerWidgetData() {
   if (GetPacketID() != XFA_XDPPACKET_Form)
     return nullptr;
-  XFA_ELEMENT classID = GetClassID();
-  if (classID == XFA_ELEMENT_ExclGroup)
+  XFA_Element classID = GetClassID();
+  if (classID == XFA_Element::ExclGroup)
     return nullptr;
   CXFA_Node* pParentNode = GetNodeItem(XFA_NODEITEM_Parent);
-  if (pParentNode && pParentNode->GetClassID() == XFA_ELEMENT_ExclGroup)
+  if (pParentNode && pParentNode->GetClassID() == XFA_Element::ExclGroup)
     return nullptr;
 
-  if (classID == XFA_ELEMENT_Field) {
+  if (classID == XFA_Element::Field) {
     CXFA_WidgetData* pFieldWidgetData = GetWidgetData();
     if (pFieldWidgetData &&
         pFieldWidgetData->GetChoiceListOpen() ==
             XFA_ATTRIBUTEENUM_MultiSelect) {
       return nullptr;
     } else {
       CFX_WideString wsPicture;
       if (pFieldWidgetData) {
         pFieldWidgetData->GetPictureContent(wsPicture,
                                             XFA_VALUEPICTURE_DataBind);
@@ skipping 18 matching lines @@
         if (!wsPicture.IsEmpty())
           break;
         pFieldWidgetData = nullptr;
       }
       return pFieldWidgetData;
     }
   }
   CXFA_Node* pGrandNode =
       pParentNode ? pParentNode->GetNodeItem(XFA_NODEITEM_Parent) : nullptr;
   CXFA_Node* pValueNode =
-      (pParentNode && pParentNode->GetClassID() == XFA_ELEMENT_Value)
+      (pParentNode && pParentNode->GetClassID() == XFA_Element::Value)
           ? pParentNode
           : nullptr;
   if (!pValueNode) {
-    pValueNode = (pGrandNode && pGrandNode->GetClassID() == XFA_ELEMENT_Value)
+    pValueNode = (pGrandNode && pGrandNode->GetClassID() == XFA_Element::Value)
                      ? pGrandNode
                      : nullptr;
   }
   CXFA_Node* pParentOfValueNode =
       pValueNode ? pValueNode->GetNodeItem(XFA_NODEITEM_Parent) : nullptr;
   return pParentOfValueNode ? pParentOfValueNode->GetContainerWidgetData()
                             : nullptr;
 }
 
 FX_BOOL CXFA_Node::GetLocaleName(CFX_WideString& wsLocaleName) {
   CXFA_Node* pForm = GetDocument()->GetXFAObject(XFA_HASHCODE_Form)->AsNode();
-  CXFA_Node* pTopSubform = pForm->GetFirstChildByClass(XFA_ELEMENT_Subform);
+  CXFA_Node* pTopSubform = pForm->GetFirstChildByClass(XFA_Element::Subform);
   ASSERT(pTopSubform);
   CXFA_Node* pLocaleNode = this;
   FX_BOOL bLocale = FALSE;
   do {
     bLocale = pLocaleNode->TryCData(XFA_ATTRIBUTE_Locale, wsLocaleName, FALSE);
     if (!bLocale) {
       pLocaleNode = pLocaleNode->GetNodeItem(XFA_NODEITEM_Parent);
     }
   } while (pLocaleNode && pLocaleNode != pTopSubform && !bLocale);
   if (bLocale)
     return TRUE;
   CXFA_Node* pConfig = ToNode(GetDocument()->GetXFAObject(XFA_HASHCODE_Config));
   wsLocaleName = GetDocument()->GetLocalMgr()->GetConfigLocaleName(pConfig);
   if (!wsLocaleName.IsEmpty())
     return TRUE;
   if (pTopSubform &&
       pTopSubform->TryCData(XFA_ATTRIBUTE_Locale, wsLocaleName, FALSE)) {
     return TRUE;
   }
   IFX_Locale* pLocale = GetDocument()->GetLocalMgr()->GetDefLocale();
   if (pLocale) {
     wsLocaleName = pLocale->GetName();
     return TRUE;
   }
   return FALSE;
 }
 
 XFA_ATTRIBUTEENUM CXFA_Node::GetIntact() {
-  XFA_ELEMENT eElement = GetClassID();
-  CXFA_Node* pKeep = GetFirstChildByClass(XFA_ELEMENT_Keep);
+  XFA_Element eElement = GetClassID();
+  CXFA_Node* pKeep = GetFirstChildByClass(XFA_Element::Keep);
   XFA_ATTRIBUTEENUM eLayoutType = GetEnum(XFA_ATTRIBUTE_Layout);
   if (pKeep) {
     XFA_ATTRIBUTEENUM eIntact;
     if (pKeep->TryEnum(XFA_ATTRIBUTE_Intact, eIntact, FALSE)) {
       if (eIntact == XFA_ATTRIBUTEENUM_None &&
           eLayoutType == XFA_ATTRIBUTEENUM_Row &&
           m_pDocument->GetCurVersionMode() < XFA_VERSION_208) {
         CXFA_Node* pPreviewRow = GetNodeItem(XFA_NODEITEM_PrevSibling,
                                              XFA_ObjectType::ContainerNode);
         if (pPreviewRow &&
             pPreviewRow->GetEnum(XFA_ATTRIBUTE_Layout) ==
                 XFA_ATTRIBUTEENUM_Row) {
           XFA_ATTRIBUTEENUM eValue;
           if (pKeep->TryEnum(XFA_ATTRIBUTE_Previous, eValue, FALSE) &&
               (eValue == XFA_ATTRIBUTEENUM_ContentArea ||
                eValue == XFA_ATTRIBUTEENUM_PageArea)) {
             return XFA_ATTRIBUTEENUM_ContentArea;
           }
           CXFA_Node* pNode =
-              pPreviewRow->GetFirstChildByClass(XFA_ELEMENT_Keep);
+              pPreviewRow->GetFirstChildByClass(XFA_Element::Keep);
           if (pNode && pNode->TryEnum(XFA_ATTRIBUTE_Next, eValue, FALSE) &&
               (eValue == XFA_ATTRIBUTEENUM_ContentArea ||
                eValue == XFA_ATTRIBUTEENUM_PageArea)) {
             return XFA_ATTRIBUTEENUM_ContentArea;
           }
         }
       }
       return eIntact;
     }
   }
   switch (eElement) {
-    case XFA_ELEMENT_Subform:
+    case XFA_Element::Subform:
       switch (eLayoutType) {
         case XFA_ATTRIBUTEENUM_Position:
         case XFA_ATTRIBUTEENUM_Row:
           return XFA_ATTRIBUTEENUM_ContentArea;
         case XFA_ATTRIBUTEENUM_Tb:
         case XFA_ATTRIBUTEENUM_Table:
         case XFA_ATTRIBUTEENUM_Lr_tb:
         case XFA_ATTRIBUTEENUM_Rl_tb:
           return XFA_ATTRIBUTEENUM_None;
         default:
           break;
       }
       break;
-    case XFA_ELEMENT_Field: {
+    case XFA_Element::Field: {
       CXFA_Node* pParentNode = GetNodeItem(XFA_NODEITEM_Parent);
-      if (!pParentNode || pParentNode->GetClassID() == XFA_ELEMENT_PageArea)
+      if (!pParentNode || pParentNode->GetClassID() == XFA_Element::PageArea)
         return XFA_ATTRIBUTEENUM_ContentArea;
       if (pParentNode->GetIntact() == XFA_ATTRIBUTEENUM_None) {
         XFA_ATTRIBUTEENUM eParLayout =
             pParentNode->GetEnum(XFA_ATTRIBUTE_Layout);
         if (eParLayout == XFA_ATTRIBUTEENUM_Position ||
             eParLayout == XFA_ATTRIBUTEENUM_Row ||
             eParLayout == XFA_ATTRIBUTEENUM_Table) {
           return XFA_ATTRIBUTEENUM_None;
         }
         XFA_VERSION version = m_pDocument->GetCurVersionMode();
         if (eParLayout == XFA_ATTRIBUTEENUM_Tb && version < XFA_VERSION_208) {
           CXFA_Measurement measureH;
           if (TryMeasure(XFA_ATTRIBUTE_H, measureH, FALSE))
             return XFA_ATTRIBUTEENUM_ContentArea;
         }
         return XFA_ATTRIBUTEENUM_None;
       }
       return XFA_ATTRIBUTEENUM_ContentArea;
     }
-    case XFA_ELEMENT_Draw:
+    case XFA_Element::Draw:
       return XFA_ATTRIBUTEENUM_ContentArea;
     default:
       break;
   }
   return XFA_ATTRIBUTEENUM_None;
 }
 
 CXFA_Node* CXFA_Node::GetDataDescriptionNode() {
   if (m_ePacket == XFA_XDPPACKET_Datasets)
     return m_pAuxNode;
@@ skipping 10 matching lines @@
   if (iLength != 1) {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"resolveNode");
     return;
   }
   CFX_WideString wsExpression =
       CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsStringC());
   CXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
   if (!pScriptContext)
     return;
   CXFA_Node* refNode = this;
-  if (refNode->GetClassID() == XFA_ELEMENT_Xfa)
+  if (refNode->GetClassID() == XFA_Element::Xfa)
     refNode = ToNode(pScriptContext->GetThisObject());
   uint32_t dwFlag = XFA_RESOLVENODE_Children | XFA_RESOLVENODE_Attributes |
                     XFA_RESOLVENODE_Properties | XFA_RESOLVENODE_Parent |
                     XFA_RESOLVENODE_Siblings;
   XFA_RESOLVENODE_RS resoveNodeRS;
   int32_t iRet = pScriptContext->ResolveObjects(
       refNode, wsExpression.AsStringC(), resoveNodeRS, dwFlag);
   if (iRet < 1) {
     pArguments->GetReturnValue()->SetNull();
     return;
@@ skipping 25 matching lines @@
   }
   CFX_WideString wsExpression =
       CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsStringC());
   CFXJSE_Value* pValue = pArguments->GetReturnValue();
   if (!pValue)
     return;
   uint32_t dwFlag = XFA_RESOLVENODE_Children | XFA_RESOLVENODE_Attributes |
                     XFA_RESOLVENODE_Properties | XFA_RESOLVENODE_Parent |
                     XFA_RESOLVENODE_Siblings;
   CXFA_Node* refNode = this;
-  if (refNode->GetClassID() == XFA_ELEMENT_Xfa)
+  if (refNode->GetClassID() == XFA_Element::Xfa)
     refNode = ToNode(m_pDocument->GetScriptContext()->GetThisObject());
   Script_Som_ResolveNodeList(pValue, wsExpression, dwFlag, refNode);
 }
 
 void CXFA_Node::Script_Som_ResolveNodeList(CFXJSE_Value* pValue,
                                            CFX_WideString wsExpression,
                                            uint32_t dwFlag,
                                            CXFA_Node* refNode) {
   CXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
   if (!pScriptContext)
@@ skipping 314 matching lines @@
         pNewChild->SetFlag(XFA_NodeFlag_Initialized, true);
         pNewChild = pItem;
       }
       while (pChild) {
         CXFA_Node* pItem = pChild->GetNodeItem(XFA_NODEITEM_NextSibling);
         RemoveChild(pChild);
         pFakeRoot->InsertChild(pChild);
         pChild = pItem;
       }
       if (GetPacketID() == XFA_XDPPACKET_Form &&
-          GetClassID() == XFA_ELEMENT_ExData) {
+          GetClassID() == XFA_Element::ExData) {
         CFDE_XMLNode* pTempXMLNode = GetXMLMappingNode();
         SetXMLMappingNode(pFakeXMLRoot);
         SetFlag(XFA_NodeFlag_OwnXMLNode, false);
         if (pTempXMLNode && !pTempXMLNode->GetNodeItem(CFDE_XMLNode::Parent)) {
           pFakeXMLRoot = pTempXMLNode;
         } else {
           pFakeXMLRoot = nullptr;
         }
       }
       MoveBufferMapData(pFakeRoot, this, XFA_CalcData, TRUE);
@@ skipping 138 matching lines @@
   else
     pValue->SetBoolean(IsContainerNode());
 }
 
 void CXFA_Node::Script_NodeClass_IsNull(CFXJSE_Value* pValue,
                                         FX_BOOL bSetting,
                                         XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     ThrowException(XFA_IDS_INVAlID_PROP_SET);
   } else {
-    if (GetClassID() == XFA_ELEMENT_Subform) {
+    if (GetClassID() == XFA_Element::Subform) {
       pValue->SetBoolean(FALSE);
       return;
     }
     CFX_WideString strValue;
     pValue->SetBoolean(!TryContent(strValue) || strValue.IsEmpty());
   }
 }
 
 void CXFA_Node::Script_NodeClass_OneOfChild(CFXJSE_Value* pValue,
                                             FX_BOOL bSetting,
@@ skipping 93 matching lines @@
   if (!pNotify)
     return;
 
   uint32_t dwPacket = GetPacketID();
   if (!(dwPacket & XFA_XDPPACKET_Form)) {
     pNotify->OnValueChanged(this, eAttribute, this, this);
     return;
   }
 
   bool bNeedFindContainer = false;
-  XFA_ELEMENT eType = GetClassID();
+  XFA_Element eType = GetClassID();
   switch (eType) {
-    case XFA_ELEMENT_Caption:
+    case XFA_Element::Caption:
       bNeedFindContainer = true;
       pNotify->OnValueChanged(this, eAttribute, this,
                               GetNodeItem(XFA_NODEITEM_Parent));
       break;
-    case XFA_ELEMENT_Font:
-    case XFA_ELEMENT_Para: {
+    case XFA_Element::Font:
+    case XFA_Element::Para: {
       bNeedFindContainer = true;
       CXFA_Node* pParentNode = GetNodeItem(XFA_NODEITEM_Parent);
-      if (pParentNode->GetClassID() == XFA_ELEMENT_Caption) {
+      if (pParentNode->GetClassID() == XFA_Element::Caption) {
         pNotify->OnValueChanged(this, eAttribute, pParentNode,
                                 pParentNode->GetNodeItem(XFA_NODEITEM_Parent));
       } else {
         pNotify->OnValueChanged(this, eAttribute, this, pParentNode);
       }
     } break;
-    case XFA_ELEMENT_Margin: {
+    case XFA_Element::Margin: {
       bNeedFindContainer = true;
       CXFA_Node* pParentNode = GetNodeItem(XFA_NODEITEM_Parent);
-      XFA_ELEMENT eParentType = pParentNode->GetClassID();
+      XFA_Element eParentType = pParentNode->GetClassID();
       if (pParentNode->IsContainerNode()) {
         pNotify->OnValueChanged(this, eAttribute, this, pParentNode);
-      } else if (eParentType == XFA_ELEMENT_Caption) {
+      } else if (eParentType == XFA_Element::Caption) {
         pNotify->OnValueChanged(this, eAttribute, pParentNode,
                                 pParentNode->GetNodeItem(XFA_NODEITEM_Parent));
       } else {
         CXFA_Node* pNode = pParentNode->GetNodeItem(XFA_NODEITEM_Parent);
-        if (pNode && pNode->GetClassID() == XFA_ELEMENT_Ui) {
+        if (pNode && pNode->GetClassID() == XFA_Element::Ui) {
           pNotify->OnValueChanged(this, eAttribute, pNode,
                                   pNode->GetNodeItem(XFA_NODEITEM_Parent));
         }
       }
     } break;
-    case XFA_ELEMENT_Comb: {
+    case XFA_Element::Comb: {
       CXFA_Node* pEditNode = GetNodeItem(XFA_NODEITEM_Parent);
-      XFA_ELEMENT eUIType = pEditNode->GetClassID();
-      if (pEditNode && (eUIType == XFA_ELEMENT_DateTimeEdit ||
-                        eUIType == XFA_ELEMENT_NumericEdit ||
-                        eUIType == XFA_ELEMENT_TextEdit)) {
+      XFA_Element eUIType = pEditNode->GetClassID();
+      if (pEditNode && (eUIType == XFA_Element::DateTimeEdit ||
+                        eUIType == XFA_Element::NumericEdit ||
+                        eUIType == XFA_Element::TextEdit)) {
         CXFA_Node* pUINode = pEditNode->GetNodeItem(XFA_NODEITEM_Parent);
         if (pUINode) {
           pNotify->OnValueChanged(this, eAttribute, pUINode,
                                   pUINode->GetNodeItem(XFA_NODEITEM_Parent));
         }
       }
     } break;
-    case XFA_ELEMENT_Button:
-    case XFA_ELEMENT_Barcode:
-    case XFA_ELEMENT_ChoiceList:
-    case XFA_ELEMENT_DateTimeEdit:
-    case XFA_ELEMENT_NumericEdit:
-    case XFA_ELEMENT_PasswordEdit:
-    case XFA_ELEMENT_TextEdit: {
+    case XFA_Element::Button:
+    case XFA_Element::Barcode:
+    case XFA_Element::ChoiceList:
+    case XFA_Element::DateTimeEdit:
+    case XFA_Element::NumericEdit:
+    case XFA_Element::PasswordEdit:
+    case XFA_Element::TextEdit: {
       CXFA_Node* pUINode = GetNodeItem(XFA_NODEITEM_Parent);
       if (pUINode) {
         pNotify->OnValueChanged(this, eAttribute, pUINode,
                                 pUINode->GetNodeItem(XFA_NODEITEM_Parent));
       }
     } break;
-    case XFA_ELEMENT_CheckButton: {
+    case XFA_Element::CheckButton: {
       bNeedFindContainer = true;
       CXFA_Node* pUINode = GetNodeItem(XFA_NODEITEM_Parent);
       if (pUINode) {
         pNotify->OnValueChanged(this, eAttribute, pUINode,
                                 pUINode->GetNodeItem(XFA_NODEITEM_Parent));
       }
     } break;
-    case XFA_ELEMENT_Keep:
-    case XFA_ELEMENT_Bookend:
-    case XFA_ELEMENT_Break:
-    case XFA_ELEMENT_BreakAfter:
-    case XFA_ELEMENT_BreakBefore:
-    case XFA_ELEMENT_Overflow:
+    case XFA_Element::Keep:
+    case XFA_Element::Bookend:
+    case XFA_Element::Break:
+    case XFA_Element::BreakAfter:
+    case XFA_Element::BreakBefore:
+    case XFA_Element::Overflow:
       bNeedFindContainer = true;
       break;
-    case XFA_ELEMENT_Area:
-    case XFA_ELEMENT_Draw:
-    case XFA_ELEMENT_ExclGroup:
-    case XFA_ELEMENT_Field:
-    case XFA_ELEMENT_Subform:
-    case XFA_ELEMENT_SubformSet:
+    case XFA_Element::Area:
+    case XFA_Element::Draw:
+    case XFA_Element::ExclGroup:
+    case XFA_Element::Field:
+    case XFA_Element::Subform:
+    case XFA_Element::SubformSet:
       pLayoutPro->AddChangedContainer(this);
       pNotify->OnValueChanged(this, eAttribute, this, this);
       break;
-    case XFA_ELEMENT_Sharptext:
-    case XFA_ELEMENT_Sharpxml:
-    case XFA_ELEMENT_SharpxHTML: {
+    case XFA_Element::Sharptext:
+    case XFA_Element::Sharpxml:
+    case XFA_Element::SharpxHTML: {
       CXFA_Node* pTextNode = GetNodeItem(XFA_NODEITEM_Parent);
       if (!pTextNode) {
         return;
       }
       CXFA_Node* pValueNode = pTextNode->GetNodeItem(XFA_NODEITEM_Parent);
       if (!pValueNode) {
         return;
       }
-      XFA_ELEMENT eNodeType = pValueNode->GetClassID();
-      if (eNodeType == XFA_ELEMENT_Value) {
+      XFA_Element eNodeType = pValueNode->GetClassID();
+      if (eNodeType == XFA_Element::Value) {
         bNeedFindContainer = true;
         CXFA_Node* pNode = pValueNode->GetNodeItem(XFA_NODEITEM_Parent);
         if (pNode && pNode->IsContainerNode()) {
           if (bScriptModify) {
             pValueNode = pNode;
           }
           pNotify->OnValueChanged(this, eAttribute, pValueNode, pNode);
         } else {
           pNotify->OnValueChanged(this, eAttribute, pNode,
                                   pNode->GetNodeItem(XFA_NODEITEM_Parent));
         }
       } else {
-        if (eNodeType == XFA_ELEMENT_Items) {
+        if (eNodeType == XFA_Element::Items) {
           CXFA_Node* pNode = pValueNode->GetNodeItem(XFA_NODEITEM_Parent);
           if (pNode && pNode->IsContainerNode()) {
             pNotify->OnValueChanged(this, eAttribute, pValueNode, pNode);
           }
         }
       }
     } break;
     default:
       break;
   }
@@ skipping 10 matching lines @@
     }
   }
 }
 
 void CXFA_Node::Script_Attribute_String(CFXJSE_Value* pValue,
                                         FX_BOOL bSetting,
                                         XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     CFX_WideString wsValue = pValue->ToWideString();
     SetAttribute(eAttribute, wsValue.AsStringC(), true);
-    if (eAttribute == XFA_ATTRIBUTE_Use && GetClassID() == XFA_ELEMENT_Desc) {
+    if (eAttribute == XFA_ATTRIBUTE_Use && GetClassID() == XFA_Element::Desc) {
       CXFA_Node* pTemplateNode =
           ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Template));
       CXFA_Node* pProtoRoot =
-          pTemplateNode->GetFirstChildByClass(XFA_ELEMENT_Subform)
-              ->GetFirstChildByClass(XFA_ELEMENT_Proto);
+          pTemplateNode->GetFirstChildByClass(XFA_Element::Subform)
+              ->GetFirstChildByClass(XFA_Element::Proto);
 
       CFX_WideString wsID;
       CFX_WideString wsSOM;
       if (!wsValue.IsEmpty()) {
         if (wsValue[0] == '#') {
           wsID = CFX_WideString(wsValue.c_str() + 1, wsValue.GetLength() - 1);
         } else {
           wsSOM = wsValue;
         }
       }
@@ skipping 143 matching lines @@
     if (!pWidgetData) {
       pValue->SetInteger(0);
       return;
     }
     pValue->SetInteger(pWidgetData->CountChoiceListItems(TRUE));
   }
 }
 void CXFA_Node::Script_Som_DefaultValue(CFXJSE_Value* pValue,
                                         FX_BOOL bSetting,
                                         XFA_ATTRIBUTE eAttribute) {
-  XFA_ELEMENT classID = GetClassID();
-  if (classID == XFA_ELEMENT_Field) {
+  XFA_Element classID = GetClassID();
+  if (classID == XFA_Element::Field) {
     Script_Field_DefaultValue(pValue, bSetting, eAttribute);
     return;
-  } else if (classID == XFA_ELEMENT_Draw) {
+  } else if (classID == XFA_Element::Draw) {
     Script_Draw_DefaultValue(pValue, bSetting, eAttribute);
     return;
-  } else if (classID == XFA_ELEMENT_Boolean) {
+  } else if (classID == XFA_Element::Boolean) {
     Script_Boolean_Value(pValue, bSetting, eAttribute);
     return;
   }
   if (bSetting) {
     CFX_WideString wsNewValue;
     if (!(pValue && (pValue->IsNull() || pValue->IsUndefined())))
       wsNewValue = pValue->ToWideString();
 
     CFX_WideString wsFormatValue(wsNewValue);
     CXFA_WidgetData* pContainerWidgetData = nullptr;
@@ skipping 18 matching lines @@
       }
     } else if (GetPacketID() == XFA_XDPPACKET_Form) {
       pContainerWidgetData = GetContainerWidgetData();
     }
     if (pContainerWidgetData) {
       pContainerWidgetData->GetFormatDataValue(wsNewValue, wsFormatValue);
     }
     SetScriptContent(wsNewValue, wsFormatValue, true, TRUE);
   } else {
     CFX_WideString content = GetScriptContent(TRUE);
-    if (content.IsEmpty() && classID != XFA_ELEMENT_Text &&
-        classID != XFA_ELEMENT_SubmitUrl) {
+    if (content.IsEmpty() && classID != XFA_Element::Text &&
+        classID != XFA_Element::SubmitUrl) {
       pValue->SetNull();
-    } else if (classID == XFA_ELEMENT_Integer) {
+    } else if (classID == XFA_Element::Integer) {
       pValue->SetInteger(FXSYS_wtoi(content.c_str()));
-    } else if (classID == XFA_ELEMENT_Float || classID == XFA_ELEMENT_Decimal) {
+    } else if (classID == XFA_Element::Float ||
+               classID == XFA_Element::Decimal) {
       CFX_Decimal decimal(content.AsStringC());
       pValue->SetFloat((FX_FLOAT)(double)decimal);
     } else {
       pValue->SetString(
           FX_UTF8Encode(content.c_str(), content.GetLength()).AsStringC());
     }
   }
 }
 void CXFA_Node::Script_Som_DefaultValue_Read(CFXJSE_Value* pValue,
                                              FX_BOOL bSetting,
@@ skipping 219 matching lines @@
     ThrowException(XFA_IDS_INVAlID_PROP_SET);
   }
 }
 void CXFA_Node::Script_Draw_DefaultValue(CFXJSE_Value* pValue,
                                          FX_BOOL bSetting,
                                          XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     if (pValue && pValue->IsString()) {
       CXFA_WidgetData* pWidgetData = GetWidgetData();
       ASSERT(pWidgetData);
-      XFA_ELEMENT uiType = pWidgetData->GetUIType();
-      if (uiType == XFA_ELEMENT_Text) {
+      XFA_Element uiType = pWidgetData->GetUIType();
+      if (uiType == XFA_Element::Text) {
         CFX_WideString wsNewValue = pValue->ToWideString();
         CFX_WideString wsFormatValue(wsNewValue);
         SetScriptContent(wsNewValue, wsFormatValue, true, TRUE);
       }
     }
   } else {
     CFX_WideString content = GetScriptContent(TRUE);
     if (content.IsEmpty()) {
       pValue->SetNull();
     } else {
@@ skipping 15 matching lines @@
       pWidgetData->m_bIsNull = TRUE;
     } else {
       pWidgetData->m_bPreNull = pWidgetData->m_bIsNull;
       pWidgetData->m_bIsNull = FALSE;
     }
     CFX_WideString wsNewText;
     if (!(pValue && (pValue->IsNull() || pValue->IsUndefined())))
       wsNewText = pValue->ToWideString();
 
     CXFA_Node* pUIChild = pWidgetData->GetUIChild();
-    if (pUIChild->GetClassID() == XFA_ELEMENT_NumericEdit) {
+    if (pUIChild->GetClassID() == XFA_Element::NumericEdit) {
       int32_t iLeadDigits = 0;
       int32_t iFracDigits = 0;
       pWidgetData->GetLeadDigits(iLeadDigits);
       pWidgetData->GetFracDigits(iFracDigits);
       wsNewText =
           pWidgetData->NumericLimit(wsNewText, iLeadDigits, iFracDigits);
     }
     CXFA_WidgetData* pContainerWidgetData = GetContainerWidgetData();
     CFX_WideString wsFormatText(wsNewText);
     if (pContainerWidgetData) {
       pContainerWidgetData->GetFormatDataValue(wsNewText, wsFormatText);
     }
     SetScriptContent(wsNewText, wsFormatText, true, TRUE);
   } else {
     CFX_WideString content = GetScriptContent(TRUE);
     if (content.IsEmpty()) {
       pValue->SetNull();
     } else {
       CXFA_Node* pUIChild = pWidgetData->GetUIChild();
-      XFA_ELEMENT eUI = pUIChild->GetClassID();
+      XFA_Element eUI = pUIChild->GetClassID();
       CXFA_Value defVal = pWidgetData->GetFormValue();
       CXFA_Node* pNode = defVal.GetNode()->GetNodeItem(XFA_NODEITEM_FirstChild);
-      if (pNode && pNode->GetClassID() == XFA_ELEMENT_Decimal) {
-        if (eUI == XFA_ELEMENT_NumericEdit &&
+      if (pNode && pNode->GetClassID() == XFA_Element::Decimal) {
+        if (eUI == XFA_Element::NumericEdit &&
             (pNode->GetInteger(XFA_ATTRIBUTE_FracDigits) == -1)) {
           pValue->SetString(
               FX_UTF8Encode(content.c_str(), content.GetLength()).AsStringC());
         } else {
           CFX_Decimal decimal(content.AsStringC());
           pValue->SetFloat((FX_FLOAT)(double)decimal);
         }
-      } else if (pNode && pNode->GetClassID() == XFA_ELEMENT_Integer) {
+      } else if (pNode && pNode->GetClassID() == XFA_Element::Integer) {
         pValue->SetInteger(FXSYS_wtoi(content.c_str()));
-      } else if (pNode && pNode->GetClassID() == XFA_ELEMENT_Boolean) {
+      } else if (pNode && pNode->GetClassID() == XFA_Element::Boolean) {
         pValue->SetBoolean(FXSYS_wtoi(content.c_str()) == 0 ? FALSE : TRUE);
-      } else if (pNode && pNode->GetClassID() == XFA_ELEMENT_Float) {
+      } else if (pNode && pNode->GetClassID() == XFA_Element::Float) {
         CFX_Decimal decimal(content.AsStringC());
         pValue->SetFloat((FX_FLOAT)(double)decimal);
       } else {
         pValue->SetString(
             FX_UTF8Encode(content.c_str(), content.GetLength()).AsStringC());
       }
     }
   }
 }
 void CXFA_Node::Script_Field_EditValue(CFXJSE_Value* pValue,
@@ skipping 120 matching lines @@
     return;
   }
   pWidgetData->DeleteItem(-1, TRUE);
 }
 void CXFA_Node::Script_Field_ExecEvent(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 1) {
     CFX_ByteString eventString = pArguments->GetUTF8String(0);
     int32_t iRet = execSingleEventByName(
         CFX_WideString::FromUTF8(eventString.AsStringC()).AsStringC(),
-        XFA_ELEMENT_Field);
+        XFA_Element::Field);
     if (eventString == "validate") {
       pArguments->GetReturnValue()->SetBoolean(
           (iRet == XFA_EVENTERROR_Error) ? FALSE : TRUE);
     }
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execEvent");
   }
 }
 void CXFA_Node::Script_Field_ExecInitialize(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
@@ skipping 206 matching lines @@
 }
 void CXFA_Node::Script_ExclGroup_Transient(CFXJSE_Value* pValue,
                                            FX_BOOL bSetting,
                                            XFA_ATTRIBUTE eAttribute) {}
 void CXFA_Node::Script_ExclGroup_ExecEvent(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 1) {
     CFX_ByteString eventString = pArguments->GetUTF8String(0);
     execSingleEventByName(
         CFX_WideString::FromUTF8(eventString.AsStringC()).AsStringC(),
-        XFA_ELEMENT_ExclGroup);
+        XFA_Element::ExclGroup);
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execEvent");
   }
 }
 
 void CXFA_Node::Script_ExclGroup_SelectedMember(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc < 0 || argc > 1) {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"selectedMember");
     return;
@@ skipping 61 matching lines @@
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execValidate");
   }
 }
 static CXFA_Node* XFA_ScriptInstanceManager_GetItem(CXFA_Node* pInstMgrNode,
                                                     int32_t iIndex) {
   ASSERT(pInstMgrNode);
   int32_t iCount = 0;
   uint32_t dwNameHash = 0;
   for (CXFA_Node* pNode = pInstMgrNode->GetNodeItem(XFA_NODEITEM_NextSibling);
        pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    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)) {
       continue;
     }
     if (iCount == 0) {
       CFX_WideStringC wsName = pNode->GetCData(XFA_ATTRIBUTE_Name);
       CFX_WideStringC wsInstName = pInstMgrNode->GetCData(XFA_ATTRIBUTE_Name);
       if (wsInstName.GetLength() < 1 || wsInstName.GetAt(0) != '_' ||
           wsInstName.Mid(1) != wsName) {
         return nullptr;
       }
       dwNameHash = pNode->GetNameHash();
@@ skipping 10 matching lines @@
 }
 void CXFA_Node::Script_Som_InstanceIndex(CFXJSE_Value* pValue,
                                          FX_BOOL bSetting,
                                          XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     int32_t iTo = pValue->ToInteger();
     int32_t iFrom = Subform_and_SubformSet_InstanceIndex();
     CXFA_Node* pManagerNode = nullptr;
     for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_PrevSibling); pNode;
          pNode = pNode->GetNodeItem(XFA_NODEITEM_PrevSibling)) {
-      if (pNode->GetClassID() == XFA_ELEMENT_InstanceManager) {
+      if (pNode->GetClassID() == XFA_Element::InstanceManager) {
         pManagerNode = pNode;
         break;
       }
     }
     if (pManagerNode) {
       pManagerNode->InstanceManager_MoveInstance(iTo, iFrom);
       CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
       if (!pNotify) {
         return;
       }
       CXFA_Node* pToInstance =
           XFA_ScriptInstanceManager_GetItem(pManagerNode, iTo);
-      if (pToInstance && pToInstance->GetClassID() == XFA_ELEMENT_Subform) {
+      if (pToInstance && pToInstance->GetClassID() == XFA_Element::Subform) {
         pNotify->RunSubformIndexChange(pToInstance);
       }
       CXFA_Node* pFromInstance =
           XFA_ScriptInstanceManager_GetItem(pManagerNode, iFrom);
-      if (pFromInstance && pFromInstance->GetClassID() == XFA_ELEMENT_Subform) {
+      if (pFromInstance &&
+          pFromInstance->GetClassID() == XFA_Element::Subform) {
         pNotify->RunSubformIndexChange(pFromInstance);
       }
     }
   } else {
     pValue->SetInteger(Subform_and_SubformSet_InstanceIndex());
   }
 }
 void CXFA_Node::Script_Subform_InstanceManager(CFXJSE_Value* pValue,
                                                FX_BOOL bSetting,
                                                XFA_ATTRIBUTE eAttribute) {
   if (!bSetting) {
     CFX_WideStringC wsName = GetCData(XFA_ATTRIBUTE_Name);
     CXFA_Node* pInstanceMgr = nullptr;
     for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_PrevSibling); pNode;
          pNode = pNode->GetNodeItem(XFA_NODEITEM_PrevSibling)) {
-      if (pNode->GetClassID() == XFA_ELEMENT_InstanceManager) {
+      if (pNode->GetClassID() == XFA_Element::InstanceManager) {
         CFX_WideStringC wsInstMgrName = pNode->GetCData(XFA_ATTRIBUTE_Name);
         if (wsInstMgrName.GetLength() >= 1 && wsInstMgrName.GetAt(0) == '_' &&
             wsInstMgrName.Mid(1) == wsName) {
           pInstanceMgr = pNode;
         }
         break;
       }
     }
     if (pInstanceMgr) {
       pValue->Assign(
@@ skipping 17 matching lines @@
         FX_UTF8Encode(wsLocaleName.c_str(), wsLocaleName.GetLength())
             .AsStringC());
   }
 }
 void CXFA_Node::Script_Subform_ExecEvent(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 1) {
     CFX_ByteString eventString = pArguments->GetUTF8String(0);
     execSingleEventByName(
         CFX_WideString::FromUTF8(eventString.AsStringC()).AsStringC(),
-        XFA_ELEMENT_Subform);
+        XFA_Element::Subform);
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execEvent");
   }
 }
 void CXFA_Node::Script_Subform_ExecInitialize(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
     CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
     if (!pNotify) {
       return;
@@ skipping 34 matching lines @@
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"getInvalidObjects");
   }
 }
 int32_t CXFA_Node::Subform_and_SubformSet_InstanceIndex() {
   int32_t index = 0;
   for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_PrevSibling); pNode;
        pNode = pNode->GetNodeItem(XFA_NODEITEM_PrevSibling)) {
-    if ((pNode->GetClassID() == XFA_ELEMENT_Subform) ||
-        (pNode->GetClassID() == XFA_ELEMENT_SubformSet)) {
+    if ((pNode->GetClassID() == XFA_Element::Subform) ||
+        (pNode->GetClassID() == XFA_Element::SubformSet)) {
       index++;
     } else {
       break;
     }
   }
   return index;
 }
 void CXFA_Node::Script_Template_FormNodes(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 1) {
@@ skipping 132 matching lines @@
   }
   CXFA_Occur nodeOccur(GetOccurNode());
   pValue->SetInteger(nodeOccur.GetMin());
 }
 static int32_t XFA_ScriptInstanceManager_GetCount(CXFA_Node* pInstMgrNode) {
   ASSERT(pInstMgrNode);
   int32_t iCount = 0;
   uint32_t dwNameHash = 0;
   for (CXFA_Node* pNode = pInstMgrNode->GetNodeItem(XFA_NODEITEM_NextSibling);
        pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    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)) {
       continue;
     }
     if (iCount == 0) {
       CFX_WideStringC wsName = pNode->GetCData(XFA_ATTRIBUTE_Name);
       CFX_WideStringC wsInstName = pInstMgrNode->GetCData(XFA_ATTRIBUTE_Name);
       if (wsInstName.GetLength() < 1 || wsInstName.GetAt(0) != '_' ||
           wsInstName.Mid(1) != wsName) {
         return iCount;
       }
       dwNameHash = pNode->GetNameHash();
@@ skipping 265 matching lines @@
     return;
   }
   int32_t iFrom = pArguments->GetInt32(0);
   int32_t iTo = pArguments->GetInt32(1);
   InstanceManager_MoveInstance(iTo, iFrom);
   CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
   if (!pNotify) {
     return;
   }
   CXFA_Node* pToInstance = XFA_ScriptInstanceManager_GetItem(this, iTo);
-  if (pToInstance && pToInstance->GetClassID() == XFA_ELEMENT_Subform) {
+  if (pToInstance && pToInstance->GetClassID() == XFA_Element::Subform) {
     pNotify->RunSubformIndexChange(pToInstance);
   }
   CXFA_Node* pFromInstance = XFA_ScriptInstanceManager_GetItem(this, iFrom);
-  if (pFromInstance && pFromInstance->GetClassID() == XFA_ELEMENT_Subform) {
+  if (pFromInstance && pFromInstance->GetClassID() == XFA_Element::Subform) {
     pNotify->RunSubformIndexChange(pFromInstance);
   }
 }
 void CXFA_Node::Script_InstanceManager_RemoveInstance(
     CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc != 1) {
     pArguments->GetReturnValue()->SetUndefined();
     return;
   }
   int32_t iIndex = pArguments->GetInt32(0);
   int32_t iCount = XFA_ScriptInstanceManager_GetCount(this);
   if (iIndex < 0 || iIndex >= iCount) {
     ThrowException(XFA_IDS_INDEX_OUT_OF_BOUNDS);
     return;
   }
   CXFA_Occur nodeOccur(GetOccurNode());
   int32_t iMin = nodeOccur.GetMin();
   if (iCount - 1 < iMin) {
     ThrowException(XFA_IDS_VIOLATE_BOUNDARY, L"min");
     return;
   }
   CXFA_Node* pRemoveInstance = XFA_ScriptInstanceManager_GetItem(this, iIndex);
   XFA_ScriptInstanceManager_RemoveItem(this, pRemoveInstance);
   CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
   if (pNotify) {
     for (int32_t i = iIndex; i < iCount - 1; i++) {
       CXFA_Node* pSubformInstance = XFA_ScriptInstanceManager_GetItem(this, i);
       if (pSubformInstance &&
-          pSubformInstance->GetClassID() == XFA_ELEMENT_Subform) {
+          pSubformInstance->GetClassID() == XFA_Element::Subform) {
         pNotify->RunSubformIndexChange(pSubformInstance);
       }
     }
   }
   CXFA_LayoutProcessor* pLayoutPro = m_pDocument->GetLayoutProcessor();
   if (!pLayoutPro) {
     return;
   }
   pLayoutPro->AddChangedContainer(
       ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Form)));
@@ skipping 107 matching lines @@
         CFX_WideString(wsInstManagerName.IsEmpty() ? wsInstManagerName
                                                    : wsInstManagerName.Mid(1));
     uint32_t dInstanceNameHash =
         FX_HashCode_GetW(wsInstanceName.AsStringC(), false);
     CXFA_Node* pPrevSibling =
         (iDesired == 0) ? this
                         : XFA_ScriptInstanceManager_GetItem(this, iDesired - 1);
     while (iCount > iDesired) {
       CXFA_Node* pRemoveInstance =
           pPrevSibling->GetNodeItem(XFA_NODEITEM_NextSibling);
-      if (pRemoveInstance->GetClassID() != XFA_ELEMENT_Subform &&
-          pRemoveInstance->GetClassID() != XFA_ELEMENT_SubformSet) {
+      if (pRemoveInstance->GetClassID() != XFA_Element::Subform &&
+          pRemoveInstance->GetClassID() != XFA_Element::SubformSet) {
         continue;
       }
-      if (pRemoveInstance->GetClassID() == XFA_ELEMENT_InstanceManager) {
+      if (pRemoveInstance->GetClassID() == XFA_Element::InstanceManager) {
         ASSERT(FALSE);
         break;
       }
       if (pRemoveInstance->GetNameHash() == dInstanceNameHash) {
         XFA_ScriptInstanceManager_RemoveItem(this, pRemoveInstance);
         iCount--;
       }
     }
   } else if (iDesired > iCount) {
     while (iCount < iDesired) {
@@ skipping 390 matching lines @@
                                       FX_BOOL bSetting,
                                       XFA_ATTRIBUTE eAttribute) {}
 enum XFA_KEYTYPE {
   XFA_KEYTYPE_Custom,
   XFA_KEYTYPE_Element,
 };
 void* XFA_GetMapKey_Custom(const CFX_WideStringC& wsKey) {
   uint32_t dwKey = FX_HashCode_GetW(wsKey, false);
   return (void*)(uintptr_t)((dwKey << 1) | XFA_KEYTYPE_Custom);
 }
-void* XFA_GetMapKey_Element(XFA_ELEMENT eElement, XFA_ATTRIBUTE eAttribute) {
-  return (void*)(uintptr_t)((eElement << 16) | (eAttribute << 8) |
-                            XFA_KEYTYPE_Element);
+void* XFA_GetMapKey_Element(XFA_Element eElement, XFA_ATTRIBUTE eAttribute) {
+  return (void*)(uintptr_t)((static_cast<int32_t>(eElement) << 16) |
+                            (eAttribute << 8) | XFA_KEYTYPE_Element);
 }
 FX_BOOL CXFA_Node::HasAttribute(XFA_ATTRIBUTE eAttr, FX_BOOL bCanInherit) {
   void* pKey = XFA_GetMapKey_Element(GetClassID(), eAttr);
   return HasMapModuleKey(pKey, bCanInherit);
 }
 FX_BOOL CXFA_Node::SetAttribute(XFA_ATTRIBUTE eAttr,
                                 const CFX_WideStringC& wsValue,
                                 bool bNotify) {
   const XFA_ATTRIBUTEINFO* pAttr = XFA_GetAttributeByID(eAttr);
   if (!pAttr)
@@ skipping 194 matching lines @@
     if (eAttr == XFA_ATTRIBUTE_Name)
       UpdateNameHash();
   }
   OnChanged(eAttr, bNotify, bScriptModify);
 
   if (!IsNeedSavingXMLNode() || eAttr == XFA_ATTRIBUTE_QualifiedName ||
       eAttr == XFA_ATTRIBUTE_BindingNode) {
     return TRUE;
   }
 
-  if (eAttr == XFA_ATTRIBUTE_Name && (m_eNodeClass == XFA_ELEMENT_DataValue ||
-                                      m_eNodeClass == XFA_ELEMENT_DataGroup)) {
+  if (eAttr == XFA_ATTRIBUTE_Name && (m_eNodeClass == XFA_Element::DataValue ||
+                                      m_eNodeClass == XFA_Element::DataGroup)) {
     return TRUE;
   }
 
   if (eAttr == XFA_ATTRIBUTE_Value) {
     FDE_XMLNODETYPE eXMLType = m_pXMLNode->GetType();
     switch (eXMLType) {
       case FDE_XMLNODE_Element:
         if (IsAttributeInXML()) {
           static_cast<CFDE_XMLElement*>(m_pXMLNode)
               ->SetString(CFX_WideString(GetCData(XFA_ATTRIBUTE_QualifiedName)),
@@ skipping 221 matching lines @@
 FX_BOOL CXFA_Node::SetScriptContent(const CFX_WideString& wsContent,
                                     const CFX_WideString& wsXMLValue,
                                     bool bNotify,
                                     FX_BOOL bScriptModify,
                                     FX_BOOL bSyncData) {
   CXFA_Node* pNode = nullptr;
   CXFA_Node* pBindNode = nullptr;
   switch (GetObjectType()) {
     case XFA_ObjectType::ContainerNode: {
       if (XFA_FieldIsMultiListBox(this)) {
-        CXFA_Node* pValue = GetProperty(0, XFA_ELEMENT_Value);
+        CXFA_Node* pValue = GetProperty(0, XFA_Element::Value);
         CXFA_Node* pChildValue = pValue->GetNodeItem(XFA_NODEITEM_FirstChild);
         ASSERT(pChildValue);
         pChildValue->SetCData(XFA_ATTRIBUTE_ContentType, L"text/xml");
         pChildValue->SetScriptContent(wsContent, wsContent, bNotify,
                                       bScriptModify, FALSE);
         CXFA_Node* pBind = GetBindData();
         if (bSyncData && pBind) {
           CFX_WideStringArray wsSaveTextArray;
           int32_t iSize = 0;
           if (!wsContent.IsEmpty()) {
@@ skipping 15 matching lines @@
             iSize = wsSaveTextArray.GetSize();
           }
           if (iSize == 0) {
             while (CXFA_Node* pChildNode =
                        pBind->GetNodeItem(XFA_NODEITEM_FirstChild)) {
               pBind->RemoveChild(pChildNode);
             }
           } else {
             CXFA_NodeArray valueNodes;
             int32_t iDatas = pBind->GetNodeList(
-                valueNodes, XFA_NODEFILTER_Children, XFA_ELEMENT_DataValue);
+                valueNodes, XFA_NODEFILTER_Children, XFA_Element::DataValue);
             if (iDatas < iSize) {
               int32_t iAddNodes = iSize - iDatas;
               CXFA_Node* pValueNodes = nullptr;
               while (iAddNodes-- > 0) {
                 pValueNodes =
-                    pBind->CreateSamePacketNode(XFA_ELEMENT_DataValue);
+                    pBind->CreateSamePacketNode(XFA_Element::DataValue);
                 pValueNodes->SetCData(XFA_ATTRIBUTE_Name, L"value");
                 pValueNodes->CreateXMLMappingNode();
                 pBind->InsertChild(pValueNodes);
               }
               pValueNodes = nullptr;
             } else if (iDatas > iSize) {
               int32_t iDelNodes = iDatas - iSize;
               while (iDelNodes-- > 0) {
                 pBind->RemoveChild(pBind->GetNodeItem(XFA_NODEITEM_FirstChild));
               }
@@ skipping 11 matching lines @@
           CXFA_NodeArray nodeArray;
           pBind->GetBindItems(nodeArray);
           for (int32_t i = 0; i < nodeArray.GetSize(); i++) {
             if (nodeArray[i] != this) {
               nodeArray[i]->SetScriptContent(wsContent, wsContent, bNotify,
                                              bScriptModify, FALSE);
             }
           }
         }
         break;
-      } else if (GetClassID() == XFA_ELEMENT_ExclGroup) {
+      } else if (GetClassID() == XFA_Element::ExclGroup) {
         pNode = this;
       } else {
-        CXFA_Node* pValue = GetProperty(0, XFA_ELEMENT_Value);
+        CXFA_Node* pValue = GetProperty(0, XFA_Element::Value);
         CXFA_Node* pChildValue = pValue->GetNodeItem(XFA_NODEITEM_FirstChild);
         ASSERT(pChildValue);
         pChildValue->SetScriptContent(wsContent, wsContent, bNotify,
                                       bScriptModify, FALSE);
       }
       pBindNode = GetBindData();
       if (pBindNode && bSyncData) {
         pBindNode->SetScriptContent(wsContent, wsXMLValue, bNotify,
                                     bScriptModify, FALSE);
         CXFA_NodeArray nodeArray;
         pBindNode->GetBindItems(nodeArray);
         for (int32_t i = 0; i < nodeArray.GetSize(); i++) {
           if (nodeArray[i] != this) {
             nodeArray[i]->SetScriptContent(wsContent, wsContent, bNotify, true,
                                            FALSE);
           }
         }
       }
       pBindNode = nullptr;
       break;
     }
     case XFA_ObjectType::ContentNode: {
       CFX_WideString wsContentType;
-      if (GetClassID() == XFA_ELEMENT_ExData) {
+      if (GetClassID() == XFA_Element::ExData) {
         GetAttribute(XFA_ATTRIBUTE_ContentType, wsContentType, FALSE);
         if (wsContentType == FX_WSTRC(L"text/html")) {
           wsContentType = FX_WSTRC(L"");
           SetAttribute(XFA_ATTRIBUTE_ContentType, wsContentType.AsStringC());
         }
       }
       CXFA_Node* pContentRawDataNode = GetNodeItem(XFA_NODEITEM_FirstChild);
       if (!pContentRawDataNode) {
         pContentRawDataNode = CreateSamePacketNode(
-            (wsContentType == FX_WSTRC(L"text/xml")) ? XFA_ELEMENT_Sharpxml
-                                                     : XFA_ELEMENT_Sharptext);
+            (wsContentType == FX_WSTRC(L"text/xml")) ? XFA_Element::Sharpxml
+                                                     : XFA_Element::Sharptext);
         InsertChild(pContentRawDataNode);
       }
       return pContentRawDataNode->SetScriptContent(
           wsContent, wsXMLValue, bNotify, bScriptModify, bSyncData);
     } break;
     case XFA_ObjectType::NodeC:
     case XFA_ObjectType::TextNode:
       pNode = this;
       break;
     case XFA_ObjectType::NodeV:
       pNode = this;
       if (bSyncData && GetPacketID() == XFA_XDPPACKET_Form) {
         CXFA_Node* pParent = GetNodeItem(XFA_NODEITEM_Parent);
         if (pParent) {
           pParent = pParent->GetNodeItem(XFA_NODEITEM_Parent);
         }
-        if (pParent && pParent->GetClassID() == XFA_ELEMENT_Value) {
+        if (pParent && pParent->GetClassID() == XFA_Element::Value) {
           pParent = pParent->GetNodeItem(XFA_NODEITEM_Parent);
           if (pParent && pParent->IsContainerNode()) {
             pBindNode = pParent->GetBindData();
             if (pBindNode) {
               pBindNode->SetScriptContent(wsContent, wsXMLValue, bNotify,
                                           bScriptModify, FALSE);
             }
           }
         }
       }
       break;
     default:
-      if (GetClassID() == XFA_ELEMENT_DataValue) {
+      if (GetClassID() == XFA_Element::DataValue) {
         pNode = this;
         pBindNode = this;
       }
       break;
   }
   if (pNode) {
     SetAttributeValue(wsContent, wsXMLValue, bNotify, bScriptModify);
     if (pBindNode && bSyncData) {
       CXFA_NodeArray nodeArray;
       pBindNode->GetBindItems(nodeArray);
@@ skipping 20 matching lines @@
 }
 CFX_WideString CXFA_Node::GetContent() {
   return GetScriptContent();
 }
 FX_BOOL CXFA_Node::TryContent(CFX_WideString& wsContent,
                               FX_BOOL bScriptModify,
                               FX_BOOL bProto) {
   CXFA_Node* pNode = nullptr;
   switch (GetObjectType()) {
     case XFA_ObjectType::ContainerNode:
-      if (GetClassID() == XFA_ELEMENT_ExclGroup) {
+      if (GetClassID() == XFA_Element::ExclGroup) {
         pNode = this;
       } else {
-        CXFA_Node* pValue = GetChild(0, XFA_ELEMENT_Value);
+        CXFA_Node* pValue = GetChild(0, XFA_Element::Value);
         if (!pValue) {
           return FALSE;
         }
         CXFA_Node* pChildValue = pValue->GetNodeItem(XFA_NODEITEM_FirstChild);
         if (pChildValue && XFA_FieldIsMultiListBox(this)) {
           pChildValue->SetAttribute(XFA_ATTRIBUTE_ContentType,
                                     FX_WSTRC(L"text/xml"));
         }
         return pChildValue
                    ? pChildValue->TryContent(wsContent, bScriptModify, bProto)
                    : FALSE;
       }
       break;
     case XFA_ObjectType::ContentNode: {
       CXFA_Node* pContentRawDataNode = GetNodeItem(XFA_NODEITEM_FirstChild);
       if (!pContentRawDataNode) {
-        XFA_ELEMENT element = XFA_ELEMENT_Sharptext;
-        if (GetClassID() == XFA_ELEMENT_ExData) {
+        XFA_Element element = XFA_Element::Sharptext;
+        if (GetClassID() == XFA_Element::ExData) {
           CFX_WideString wsContentType;
           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 = CreateSamePacketNode(element);
         InsertChild(pContentRawDataNode);
       }
       return pContentRawDataNode->TryContent(wsContent, bScriptModify, bProto);
     }
     case XFA_ObjectType::NodeC:
     case XFA_ObjectType::NodeV:
     case XFA_ObjectType::TextNode:
       pNode = this;
     default:
-      if (GetClassID() == XFA_ELEMENT_DataValue) {
+      if (GetClassID() == XFA_Element::DataValue) {
         pNode = this;
       }
       break;
   }
   if (pNode) {
     if (bScriptModify) {
       CXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
       if (pScriptContext) {
         m_pDocument->GetScriptContext()->AddNodesOfRunScript(this);
       }
@@ skipping 21 matching lines @@
     case XFA_XDPPACKET_SourceSet:
       return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_SourceSet));
     case XFA_XDPPACKET_Xdc:
       return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Xdc));
     default:
       return this;
   }
 }
 FX_BOOL CXFA_Node::TryNamespace(CFX_WideString& wsNamespace) {
   wsNamespace.clear();
-  if (IsModelNode() || GetClassID() == XFA_ELEMENT_Packet) {
+  if (IsModelNode() || GetClassID() == XFA_Element::Packet) {
     CFDE_XMLNode* pXMLNode = GetXMLMappingNode();
     if (!pXMLNode || pXMLNode->GetType() != FDE_XMLNODE_Element) {
       return FALSE;
     }
     static_cast<CFDE_XMLElement*>(pXMLNode)->GetNamespaceURI(wsNamespace);
     return TRUE;
   } else if (GetPacketID() == XFA_XDPPACKET_Datasets) {
     CFDE_XMLNode* pXMLNode = GetXMLMappingNode();
     if (!pXMLNode) {
       return FALSE;
     }
     if (pXMLNode->GetType() != FDE_XMLNODE_Element) {
       return TRUE;
     }
-    if (GetClassID() == XFA_ELEMENT_DataValue &&
+    if (GetClassID() == XFA_Element::DataValue &&
         GetEnum(XFA_ATTRIBUTE_Contains) == XFA_ATTRIBUTEENUM_MetaData) {
       return XFA_FDEExtension_ResolveNamespaceQualifier(
           static_cast<CFDE_XMLElement*>(pXMLNode),
           GetCData(XFA_ATTRIBUTE_QualifiedName), wsNamespace);
     }
     static_cast<CFDE_XMLElement*>(pXMLNode)->GetNamespaceURI(wsNamespace);
     return TRUE;
   } else {
     CXFA_Node* pModelNode = GetModelNode();
     return pModelNode->TryNamespace(wsNamespace);
   }
 }
 CXFA_Node* CXFA_Node::GetProperty(int32_t index,
-                                  XFA_ELEMENT eProperty,
+                                  XFA_Element eProperty,
                                   FX_BOOL bCreateProperty) {
-  XFA_ELEMENT eElement = GetClassID();
+  XFA_Element eElement = GetClassID();
   uint32_t dwPacket = GetPacketID();
   const XFA_PROPERTY* pProperty =
       XFA_GetPropertyOfElement(eElement, eProperty, dwPacket);
   if (!pProperty || index >= pProperty->uOccur)
     return nullptr;
 
   CXFA_Node* pNode = m_pChild;
   int32_t iCount = 0;
   for (; pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     if (pNode->GetClassID() == eProperty) {
@@ skipping 20 matching lines @@
   CXFA_Node* pNewNode = nullptr;
   for (; iCount <= index; iCount++) {
     pNewNode = pFactory->CreateNode(pPacket, eProperty);
     if (!pNewNode)
       return nullptr;
     InsertChild(pNewNode, nullptr);
     pNewNode->SetFlag(XFA_NodeFlag_Initialized, true);
   }
   return pNewNode;
 }
-int32_t CXFA_Node::CountChildren(XFA_ELEMENT eElement, FX_BOOL bOnlyChild) {
+int32_t CXFA_Node::CountChildren(XFA_Element eElement, FX_BOOL bOnlyChild) {
   CXFA_Node* pNode = m_pChild;
   int32_t iCount = 0;
   for (; pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    if (pNode->GetClassID() == eElement || eElement == XFA_ELEMENT_UNKNOWN) {
+    if (pNode->GetClassID() == eElement || eElement == XFA_Element::Unknown) {
       if (bOnlyChild) {
         const XFA_PROPERTY* pProperty = XFA_GetPropertyOfElement(
             GetClassID(), pNode->GetClassID(), XFA_XDPPACKET_UNKNOWN);
         if (pProperty) {
           continue;
         }
       }
       iCount++;
     }
   }
   return iCount;
 }
 CXFA_Node* CXFA_Node::GetChild(int32_t index,
-                               XFA_ELEMENT eElement,
+                               XFA_Element eElement,
                                FX_BOOL bOnlyChild) {
   ASSERT(index > -1);
   CXFA_Node* pNode = m_pChild;
   int32_t iCount = 0;
   for (; pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    if (pNode->GetClassID() == eElement || eElement == XFA_ELEMENT_UNKNOWN) {
+    if (pNode->GetClassID() == eElement || eElement == XFA_Element::Unknown) {
       if (bOnlyChild) {
         const XFA_PROPERTY* pProperty = XFA_GetPropertyOfElement(
             GetClassID(), pNode->GetClassID(), XFA_XDPPACKET_UNKNOWN);
         if (pProperty) {
           continue;
         }
       }
       iCount++;
       if (iCount > index) {
         return pNode;
@@ skipping 164 matching lines @@
 }
 CXFA_Node* CXFA_Node::GetFirstChildByName(uint32_t dwNameHash) const {
   for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_FirstChild); pNode;
        pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     if (pNode->GetNameHash() == dwNameHash) {
       return pNode;
     }
   }
   return nullptr;
 }
-CXFA_Node* CXFA_Node::GetFirstChildByClass(XFA_ELEMENT eElement) const {
+CXFA_Node* CXFA_Node::GetFirstChildByClass(XFA_Element eElement) const {
   for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_FirstChild); pNode;
        pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     if (pNode->GetClassID() == eElement) {
       return pNode;
     }
   }
   return nullptr;
 }
 CXFA_Node* CXFA_Node::GetNextSameNameSibling(uint32_t dwNameHash) const {
   for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_NextSibling); pNode;
        pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     if (pNode->GetNameHash() == dwNameHash) {
       return pNode;
     }
   }
   return nullptr;
 }
 CXFA_Node* CXFA_Node::GetNextSameNameSibling(
     const CFX_WideStringC& wsNodeName) const {
   return GetNextSameNameSibling(FX_HashCode_GetW(wsNodeName, false));
 }
-CXFA_Node* CXFA_Node::GetNextSameClassSibling(XFA_ELEMENT eElement) const {
+CXFA_Node* CXFA_Node::GetNextSameClassSibling(XFA_Element eElement) const {
   for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_NextSibling); pNode;
        pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     if (pNode->GetClassID() == eElement) {
       return pNode;
     }
   }
   return nullptr;
 }
 int32_t CXFA_Node::GetNodeSameNameIndex() const {
   CXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
@@ skipping 13 matching lines @@
   CXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
   if (!pScriptContext) {
     return;
   }
   pScriptContext->GetSomExpression(this, wsSOMExpression);
 }
 CXFA_Node* CXFA_Node::GetInstanceMgrOfSubform() {
   CXFA_Node* pInstanceMgr = nullptr;
   if (m_ePacket == XFA_XDPPACKET_Form) {
     CXFA_Node* pParentNode = GetNodeItem(XFA_NODEITEM_Parent);
-    if (!pParentNode || pParentNode->GetClassID() == XFA_ELEMENT_Area) {
+    if (!pParentNode || pParentNode->GetClassID() == XFA_Element::Area) {
       return pInstanceMgr;
     }
     for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_PrevSibling); pNode;
          pNode = pNode->GetNodeItem(XFA_NODEITEM_PrevSibling)) {
-      XFA_ELEMENT eType = pNode->GetClassID();
-      if ((eType == XFA_ELEMENT_Subform || eType == XFA_ELEMENT_SubformSet) &&
+      XFA_Element eType = pNode->GetClassID();
+      if ((eType == XFA_Element::Subform || eType == XFA_Element::SubformSet) &&
           pNode->m_dwNameHash != m_dwNameHash) {
         break;
       }
-      if (eType == XFA_ELEMENT_InstanceManager) {
+      if (eType == XFA_Element::InstanceManager) {
         CFX_WideStringC wsName = GetCData(XFA_ATTRIBUTE_Name);
         CFX_WideStringC wsInstName = pNode->GetCData(XFA_ATTRIBUTE_Name);
         if (wsInstName.GetLength() > 0 && wsInstName.GetAt(0) == '_' &&
             wsInstName.Mid(1) == wsName) {
           pInstanceMgr = pNode;
         }
         break;
       }
     }
   }
   return pInstanceMgr;
 }
 CXFA_Node* CXFA_Node::GetOccurNode() {
-  return GetFirstChildByClass(XFA_ELEMENT_Occur);
+  return GetFirstChildByClass(XFA_Element::Occur);
 }
 bool CXFA_Node::HasFlag(XFA_NodeFlag dwFlag) const {
   if (m_uNodeFlags & dwFlag)
     return true;
   if (dwFlag == XFA_NodeFlag_HasRemovedChildren)
     return m_pParent && m_pParent->HasFlag(dwFlag);
   return false;
 }
 
 void CXFA_Node::SetFlag(uint32_t dwFlag, bool bNotify) {
@@ skipping 34 matching lines @@
 
 void CXFA_Node::OnChanged(XFA_ATTRIBUTE eAttr,
                           bool bNotify,
                           FX_BOOL bScriptModify) {
   if (bNotify && IsInitialized()) {
     Script_Attribute_SendAttributeChangeMessage(eAttr, bScriptModify);
   }
 }
 
 int32_t CXFA_Node::execSingleEventByName(const CFX_WideStringC& wsEventName,
-                                         XFA_ELEMENT eElementType) {
+                                         XFA_Element eElementType) {
   int32_t iRet = XFA_EVENTERROR_NotExist;
   const XFA_ExecEventParaInfo* eventParaInfo =
       GetEventParaInfoByName(wsEventName);
   if (eventParaInfo) {
     uint32_t validFlags = eventParaInfo->m_validFlags;
     CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
     if (!pNotify) {
       return iRet;
     }
     if (validFlags == 1) {
       iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType);
     } else if (validFlags == 2) {
       iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType,
                                            FALSE, FALSE);
     } else if (validFlags == 3) {
-      if (eElementType == XFA_ELEMENT_Subform) {
+      if (eElementType == XFA_Element::Subform) {
         iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType,
                                              FALSE, FALSE);
       }
     } else if (validFlags == 4) {
-      if (eElementType == XFA_ELEMENT_ExclGroup ||
-          eElementType == XFA_ELEMENT_Field) {
+      if (eElementType == XFA_Element::ExclGroup ||
+          eElementType == XFA_Element::Field) {
         CXFA_Node* pParentNode = GetNodeItem(XFA_NODEITEM_Parent);
-        if (pParentNode && pParentNode->GetClassID() == XFA_ELEMENT_ExclGroup) {
+        if (pParentNode &&
+            pParentNode->GetClassID() == XFA_Element::ExclGroup) {
           iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType,
                                                FALSE, FALSE);
         }
         iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType,
                                              FALSE, FALSE);
       }
     } else if (validFlags == 5) {
-      if (eElementType == XFA_ELEMENT_Field) {
+      if (eElementType == XFA_Element::Field) {
         iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType,
                                              FALSE, FALSE);
       }
     } else if (validFlags == 6) {
       CXFA_WidgetData* pWidgetData = GetWidgetData();
       if (pWidgetData) {
         CXFA_Node* pUINode = pWidgetData->GetUIChild();
-        if (pUINode->m_eNodeClass == XFA_ELEMENT_Signature) {
+        if (pUINode->m_eNodeClass == XFA_Element::Signature) {
           iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType,
                                                FALSE, FALSE);
         }
       }
     } else if (validFlags == 7) {
       CXFA_WidgetData* pWidgetData = GetWidgetData();
       if (pWidgetData) {
         CXFA_Node* pUINode = pWidgetData->GetUIChild();
-        if ((pUINode->m_eNodeClass == XFA_ELEMENT_ChoiceList) &&
+        if ((pUINode->m_eNodeClass == XFA_Element::ChoiceList) &&
             (!pWidgetData->IsListBox())) {
           iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType,
                                                FALSE, FALSE);
         }
       }
     }
   }
   return iRet;
 }
 void CXFA_Node::UpdateNameHash() {
@@ skipping 11 matching lines @@
 CFDE_XMLNode* CXFA_Node::CreateXMLMappingNode() {
   if (!m_pXMLNode) {
     CFX_WideString wsTag(GetCData(XFA_ATTRIBUTE_Name));
     m_pXMLNode = new CFDE_XMLElement(wsTag);
     SetFlag(XFA_NodeFlag_OwnXMLNode, false);
   }
   return m_pXMLNode;
 }
 FX_BOOL CXFA_Node::IsNeedSavingXMLNode() {
   return m_pXMLNode && (GetPacketID() == XFA_XDPPACKET_Datasets ||
-                        GetClassID() == XFA_ELEMENT_Xfa);
+                        GetClassID() == XFA_Element::Xfa);
 }
 
 XFA_MAPMODULEDATA* CXFA_Node::CreateMapModuleData() {
   if (!m_pMapModuleData)
     m_pMapModuleData = new XFA_MAPMODULEDATA;
   return m_pMapModuleData;
 }
 
 XFA_MAPMODULEDATA* CXFA_Node::GetMapModuleData() const {
   return m_pMapModuleData;
@@ skipping 235 matching lines @@
     for (; pSrcChild && pDstChild;
          pSrcChild = pSrcChild->GetNodeItem(XFA_NODEITEM_NextSibling),
          pDstChild = pDstChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {
       MoveBufferMapData(pSrcChild, pDstChild, pKey, TRUE);
     }
   }
   pSrcModule->MoveBufferMapData(pDstModule, pKey);
 }
 
 CXFA_OrdinaryObject::CXFA_OrdinaryObject(CXFA_Document* pDocument,
-                                         XFA_ELEMENT eElement)
+                                         XFA_Element eElement)
     : CXFA_Object(pDocument, XFA_ObjectType::OrdinaryObject), m_uScriptHash(0) {
   m_eNodeClass = eElement;
 }
 
 CXFA_OrdinaryObject::~CXFA_OrdinaryObject() {}
 
-XFA_ELEMENT CXFA_OrdinaryObject::GetClassID() const {
+XFA_Element CXFA_OrdinaryObject::GetClassID() const {
   return m_eNodeClass;
 }
 
 uint32_t CXFA_OrdinaryObject::GetScriptObjHash() const {
   return m_uScriptHash;
 }
 
 CXFA_ThisProxy::CXFA_ThisProxy(CXFA_Node* pThisNode, CXFA_Node* pScriptNode)
     : CXFA_Object(pThisNode->GetDocument(), XFA_ObjectType::VariablesThis),
       m_pThisNode(NULL),
@@ skipping 11 matching lines @@
 CXFA_Node* CXFA_ThisProxy::GetScriptNode() const {
   return m_pScriptNode;
 }
 
 CXFA_NodeList::CXFA_NodeList(CXFA_Document* pDocument)
     : CXFA_Object(pDocument, XFA_ObjectType::NodeList) {
   m_pDocument->GetScriptContext()->AddToCacheList(
       std::unique_ptr<CXFA_NodeList>(this));
 }
 CXFA_NodeList::~CXFA_NodeList() {}
-XFA_ELEMENT CXFA_NodeList::GetClassID() const {
-  return XFA_ELEMENT_NodeList;
+XFA_Element CXFA_NodeList::GetClassID() const {
+  return XFA_Element::NodeList;
 }
 CXFA_Node* CXFA_NodeList::NamedItem(const CFX_WideStringC& wsName) {
   uint32_t dwHashCode = FX_HashCode_GetW(wsName, false);
   int32_t iCount = GetLength();
   for (int32_t i = 0; i < iCount; i++) {
     CXFA_Node* ret = Item(i);
     if (dwHashCode == ret->GetNameHash())
       return ret;
   }
   return nullptr;
@@ skipping 126 matching lines @@
   }
   return nullptr;
 }
 CXFA_AttachNodeList::CXFA_AttachNodeList(CXFA_Document* pDocument,
                                          CXFA_Node* pAttachNode)
     : CXFA_NodeList(pDocument) {
   m_pAttachNode = pAttachNode;
 }
 int32_t CXFA_AttachNodeList::GetLength() {
   return m_pAttachNode->CountChildren(
-      XFA_ELEMENT_UNKNOWN, m_pAttachNode->GetClassID() == XFA_ELEMENT_Subform);
+      XFA_Element::Unknown,
+      m_pAttachNode->GetClassID() == XFA_Element::Subform);
 }
 FX_BOOL CXFA_AttachNodeList::Append(CXFA_Node* pNode) {
   CXFA_Node* pParent = pNode->GetNodeItem(XFA_NODEITEM_Parent);
   if (pParent) {
     pParent->RemoveChild(pNode);
   }
   return m_pAttachNode->InsertChild(pNode);
 }
 FX_BOOL CXFA_AttachNodeList::Insert(CXFA_Node* pNewNode,
                                     CXFA_Node* pBeforeNode) {
   CXFA_Node* pParent = pNewNode->GetNodeItem(XFA_NODEITEM_Parent);
   if (pParent) {
     pParent->RemoveChild(pNewNode);
   }
   return m_pAttachNode->InsertChild(pNewNode, pBeforeNode);
 }
 FX_BOOL CXFA_AttachNodeList::Remove(CXFA_Node* pNode) {
   return m_pAttachNode->RemoveChild(pNode);
 }
 CXFA_Node* CXFA_AttachNodeList::Item(int32_t iIndex) {
   return m_pAttachNode->GetChild(
-      iIndex, XFA_ELEMENT_UNKNOWN,
-      m_pAttachNode->GetClassID() == XFA_ELEMENT_Subform);
+      iIndex, XFA_Element::Unknown,
+      m_pAttachNode->GetClassID() == XFA_Element::Subform);
 }